Ready for the future

Lasagne
» Bolognese sauce
» Lasagne sheets
» Béchamel sauce
» Grated parmesan
Bechamel Sauce
» Butter
» Flour
» Milk
» Salt and Pepper
Context matters

View Slide

Context matters

View Slide

Context matters

An Obj-C example

An Obj-C example

An Obj-C example

The model

- (NSTimeInterval)elapsed Time {
NSDate *now = [[NSDate alloc] init];
NSTimeInterval elapsed Time = [now timeIntervalS inceDate:self.startTime];
return elapsedTime;
}

View Slide

return elapsedTime;
}

View Slide

return elapsedTime;
}

View Slide

return elapsedTime;
}

View Slide

return elapsedTime;
}

View Slide

return [self.startTime timeIntervalSinceNow];
}

View Slide

return [self.startTime timeIntervalSinceNow];
}

View Slide

return -[self.startTime timeIntervalSinceNow];
}

View Slide

return -[self.startTime timeIntervalSinceNow];
}

View Slide

return [self.startTime timeIntervalUntilNow];
}

View Slide

#import
@interface NSDate (TimerCalculations)
- (NSTimeInterval)timeIntervalUntilNow;
@end

View Slide

#import
@interface NSDate (TimerCalculations)
- (NSTimeInterval)timeIntervalUntilNow;
@end

View Slide

#import "NSDate+TimerCalculations.h"
@implementation NSDate (TimerCalculations)
- (NSTimeInterval) timeIntervalUntilNow {
return - [self timeIntervalSinceNow];
}
@end

View Slide

}
@end

View Slide

}
@end

View Slide

- (NSTimeInterval)dst_timeIntervalUntilNow {
}
@end

Context

Clean

Clear

Lasagne

- (NSTimeInterval)elapsedTime {
return [self.startTime timeInterval UntilNow];
}

View Slide

return startTime.timeIntervalUntilNow
}

View Slide

}
Exactly

View Slide

}
Let's get to
some swift

View Slide

}
Show me some
clever
unreadable code

View Slide

}
Let's see some
Generics and
Custom operators

View Slide

The model in Swift

View Slide

struct Timer {
let startTime = NSDate()
var elapsedTime: NSTimeInterval {
}
}

struct Timer {
}
}

struct Timer {
}
}

struct Timer {
}
}

}
}
extension NSDate {
var timeIntervalUntilNow: NSTimeInterval {
return -timeIntervalSinceNow
}
}

View Slide

extension NSDate {
var timeIntervalUntilNow: NSTimeInterval {
return -timeIntervalSinceNow
}
}

View Slide

Lasagne
» Bolognese sauce
» Lasagne sheets
» Béchamel sauce
» Grated parmesan
Bechamel Sauce
» Butter
» Flour
» Milk
» Salt and Pepper

Clean

Compact

Clear

UmmM, Daniel

You Started
with Obj-C

View Slide

And converted
it to Swift

View Slide

What about
Real Swift

View Slide

Show me Map,
Filter, reduce!

View Slide

Silly Example

View Slide

App Sales

View Slide

import GameplayKit
struct AppSales: SequenceType {
let numberOfDays: Int
let randomDistribution = GKGaussianDistribution(lowestValue: 0, highestValue: 10)
func generate() -> Any Generator {
var count = 0
return anyGenerator({
if count++ < self .numberOfDays {
return self .randomDistribution.nextInt()
} else {
return nil
}
})
}
}

View Slide

import GameplayKit
var count = 0
} else {
return nil
}
})
}
}

View Slide

import GameplayKit
var count = 0
} else {
return nil
}
})
}
}

View Slide

import GameplayKit
var count = 0
} else {
return nil
}
})
}
}

View Slide

import GameplayKit
var count = 0
} else {
return nil
}
})
}
}

View Slide

import GameplayKit
var count = 0
} else {
return nil
}
})
}
}

View Slide

import GameplayKit
var count = 0
} else {
return nil
}
})
}
}

View Slide

let lastWeeksSales
= AppSales(numberOfDays: 7)
for dailySales in lastWeeksSales {
print(dailySales)
}

View Slide

AppSales is a
SequenceType

View Slide

for in

View Slide

let lastWeeksSales
print(dailySales)
}

View Slide

6
5
6
4
6
4
3
let lastWeeksSales
print(dailySales)
}

View Slide

AppSales is a
SequenceType

View Slide

map, ﬁlter, reduce, ﬂatmap, …

View Slide

let lastWeeksSales = AppSales(numberOfDays: 7)
let lastWeeksRevenues = lastWeeksSales.map{dailySales in
Double(dailySales) * 1.99 * 0.70
}

}

}

}

[6.964999999999999, 8.357999999999999,
5.572, 6.964999999999999, 5.572,
4.178999999999999, 4.178999999999999]
}

}

}

Context

}

let unitPrice = 1.99
Double(dailySales) * unitPrice * 0.70
}

View Slide

Double(dailySales) * unitPrice * 0.70
}

View Slide

let sellersPercentage = 0.70
Double(dailySales) * unitPrice * sellersPercentage
}

View Slide

Double(dailySales) * unitPrice * sellersPercentage
}

View Slide

func revenuesForCopies Sold(numberOfCopies: Int) -> Double {
return Double(number OfCopies) * unitPrice * sellersPercentage
}
revenuesForCopiesSold(dailySales)
}

View Slide

revenuesForCopiesSold(dailySales)
}

View Slide

let lastWeeksRevenues = lastWeeksSales.map{revenuesForCopies Sold($0) }

View Slide

let lastWeeksRevenues = lastWeeksSales.map(revenuesForCopies Sold)

View Slide

let lastWeeksRevenues = lastWeeksSales.map(revenuesForCopies Sold)

View Slide

Adjust the distribution

View Slide

Wider

View Slide

let randomDistribution = GKGaussianDistribution(lowestValue: -5, highestValue: 15)

View Slide

Negatives count as 0

View Slide

Could ﬁlter copies > 0

View Slide

let lastWeeksRevenues = lastWeeksSales.filter{$0 > 0}
.map(revenuesForCopiesSold)

View Slide

Filter can change
size of array

View Slide

Could map
negatives -> 0

View Slide

let lastWeeksRevenues = lastWeeksSales.map{$0 > 0 ? $0 : 0}

View Slide

"Doctor it hurts when I do that."

View Slide

"Don't do that."

View Slide

let lastWeeksRevenues = lastWeeksSales.map{$0 > 0 ? $0 : 0}

View Slide

func negativeNumbersToZero (number: Int) -> Int {
return max(0, number)
}
let lastWeeksRevenues = lastWeeksSales.map(negativeNumbersToZero)

View Slide

Good News

View Slide

We'll come back
to the Lasagne.

View Slide

First, the béchamel.

View Slide

func revenues ForCopiesSold(numberOfCopies: Int) -> Double {
return Double(numberOfCopies) * unitPrice * sellersPercentage
}

View Slide

func revenues ForCopiesSold(numberOfCopies: Int) -> Double {
}

View Slide

typealias USDollars = Double
func revenues ForCopiesSold(numberOfCopies: Int) -> USDollars {
}

View Slide

}
func toThe NearestPenny(dollarAmount: USDollars) -> USDollars {
return round(dollarAmount * 100)/100
}

View Slide

}
}
func revenues InDollarsForCopiesSold(numberOfCopies: Int) -> USDollars {
return toTheNearestPenny(revenuesForCopiesSold (numberOfCopies))
}

}
}
}

}
}
}

}
}
}

Backwards

}

Method chaining

Extensions

Extensions
UmmM, Daniel

View Slide

Extensions
How did your
talk get
accepted?

View Slide

Extensions
No Generics.

View Slide

Extensions
No Custom
Operators

View Slide

Custom Operator

View Slide

Custom Operator
What?

View Slide

Custom Operator

View Slide

Custom Operator
And Generics?

View Slide

infix operator » {associativity left}
func »(input: T,
transform: T -> U) -> U {
return transform(input)
}

func »(input: T,
}

func »(input: T,
}

func »(input: T,
}

func »(input: T,
}

func »(input: T,
}

func »(input: T,
}

Clearly …

Context

func »(input: T,
}

Use it

func revenuesInDollarsForCopiesSold(number OfCopies: Int) -> USDollars {
return numberOfCopies
» revenuesForCopiesSold
» toTheNearestPenny
}

}

}

}

}

}

Back to the Lasagne

let lastWeeksRevenues = lastWeeksSales .map(negativeNumbersToZero)
.map(revenuesInDollarsForCopiesSold)

View Slide

map is like -

View Slide

Move map

View Slide

let lastWeeksRevenues = lastWeeksSales .map(negativeNumbersToZero)
.map(revenuesInDollarsForCopiesSold)

View Slide

func replaceNegativeSalesWithZeroSales(sales: [Int]) -> [Int] {
return sales.map(negativeNumbersToZero)
}
func calculateRevenuesFromSales(sales: [Int]) -> [USDollars] {
return sales.map(revenuesInDollarsFor CopiesSold)
}

Types Match

}
}

Types Don't Match

}
}

func anArrayOfDailySales(rawSales: AppSales) -> [Int] {
return rawSales.map{$0}
}

View Slide

Chain them together

View Slide

let lastWeeksRevenues = lastWeeksSales
» anArrayOfDailySales
» replaceNegativeSalesWithZeroSales
» calculateRevenuesFromSales

View Slide

Lasagne

View Slide

Lasagne
» Bolognese sauce
» Lasagne sheets
» Béchamel sauce
» Grated parmesan

View Slide

We don't do this

View Slide

Lasagne
» Bolognese sauce
» Lasagne sheets
» Béchamel sauce
̣ Butter
̣ Flour
̣ Milk
̣ Salt and Pepper
» Grated parmesan

View Slide

let lastWeeksRevenues
= lastWeeksSales
.map{$0 > 0 ? $0 : 0}
.map{round(Double($0) * unitPrice * sellersPercentage * 100)/100 }

View Slide

We zoom in

View Slide

Lasagne
» Bolognese sauce
» Lasagne sheets
» Béchamel sauce
» Grated parmesan

View Slide

Lasagne
» Bolognese sauce
» Lasagne sheets
» Béchamel sauce
» Grated parmesan
Bechamel Sauce
» Butter
» Flour
» Milk
» Salt and Pepper

View Slide

= lastWeeksSales
return sales.map(revenuesInDollars ForCopiesSold)
}

View Slide

= lastWeeksSales
return sales.map(revenuesInDollarsForCopiesSold)
}

View Slide

evenuesFromSales(sales: [Int]) -> [USDollars] {
s.map(revenuesInDollarsForCopiesSold)
func revenuesInDollarsForCopiesSold(numberOfCopies: Int) -> USDollars {
» roundedToTheNearestPenny
}

View Slide

evenuesFromSales(sales: [Int]) -> [USDollars] {
s.map(revenuesInDollarsForCopiesSold)
func revenuesInDollarsForCopiesSold(numberOfCopies: Int) -> USDollars {
}

View Slide

uesInDollarsForCopiesSold(numberOfCopies: Int) -> USDollars {
numberOfCopies
func revenuesForCopiesSold(numberOfCopies: NumberOfCopies) -> USDollars {
}

View Slide

func revenuesForCopiesSold(numberOfCopies: NumberOfCopies) -> USDollars {
}

Clean

Clear

Testable

Context

And yet …

»

}

}

typealias NumberOfCopies = Int
func revenues ForCopiesSold(numberOfCopies: Number OfCopies) -> USDollars {
}

View Slide

extension NumberOfCopies {
private func revenuesForCopiesSold() -> USDollars {
return Double(self) * unitPrice * sellersPercentage
}
}

}
}

}
}

}
}

extension USDollars {
private func roundedToTheNearestPenny() -> USDollars {
return round(self * 100)/100
}
}

}
}

}
}

}

private func revenuesIn DollarsForCopiesSold() -> USDollars {
return self.revenues ForCopiesSold().roundedToTheNearestPenny ()
}
}

}
}

}
}

}
}

}
}

}
}

}
}

7.revenuesInDollarsForCopiesSold()

View Slide

7.revenuesInDollarsForCopiesSold()
9.75

View Slide

private func revenues InDollarsForCopiesSold() -> USDollars {
return revenues ForCopiesSold().roundedToTheNearestPenny ()
}
}

Removed »

That's Béchamel

What about Lasagne?

func replace NegativeSalesWithZeroSales(sales: [Int]) -> [Int] {
}

View Slide

Where?

View Slide

extension [NumberOfCopies] {
}

Can't

extension [Int] {
}

Still Can't

Rich Hickey's Trolley

View Slide

Not bad for map()

View Slide

Wait a minute

View Slide

What does this have to
do with Lasagne?

Everything at once

Fancy made to order

Back to map()

Combine

func anArrayOf DailySales(rawSales: AppSales) -> [Int] {
}
}
func calcu lateRevenuesFromSales(sales: [Int]) -> [USDollars] {
}

View Slide

func processEndToEnd(sales: AppSales) -> USDollars {
return sales.map(transform: Int -> U)
}

View Slide

Combine

View Slide

func anArrayOf DailySales(rawSales: AppSales) -> [Int] {
}
}
func calcu lateRevenuesFromSales(sales: [Int]) -> [USDollars] {
}
}

View Slide

}

View Slide

This doesn't work

View Slide

func process EndToEnd(sales: AppSales) -> USDollars {
return sales
.map(negativeNumbersToZero
» revenuesInDollarsForCopiesSold)
}

View Slide

Types don't match

View Slide

This works …

View Slide

func combinedSteps(input: Int) -> USDollars {
return input » negativeNumbersToZero » revenuesInDollarsForCopiesSold
}
func processEndToEnd(sales: AppSales) -> [USDollars] {
return sales.map(combinedSteps)
}

}
}

}
}

}
}

Want…

return sales.map(negativeNumbersToZero » revenuesInDollarsForCopiesSold)
}

View Slide

The types

View Slide

Overload »

View Slide

func » (firstFunction: T -> U, secondFunction: U -> V) -> T -> V {
return {x in secondFunction(firstFunction(x)) }
}

}

}

}

}

let lastWeeksLazyRevenues = lastWeeksSales
.map( negativeNumbersToZero

View Slide

map

View Slide

Rich Hickey's Trolley

View Slide

ﬂatmap
T -> [U] [T] -> [ U]

View Slide

ﬁlter
T -> Bool [T] -> [ T]

View Slide

map
T -> U [T] -> [ U]

View Slide

reduce
U, (U, T) -> U [T] -> U

reduce

Béchamel

Mother Sauce

reduce

Mother Sauce

map with reduce

ﬁlter with reduce

ﬂatmap with reduce

Inefﬁcient

Instructive

reduce

reduce
U, (U, T) -> U

View Slide

reduce
U, (U, T) -> U
initial value

View Slide

reduce
U, (U, T) -> U step

View Slide

reduce
U, (U, T) -> U

View Slide

map with reduce

View Slide

extension SequenceType {
func mapUsingReduce (transform: Generator.Element -> U) -> [U] {
let initialValue = [U]()
func step(accu mulatedValue: [U], nextElement: Generator .Element) -> [U] {
return acc umulatedValue + [transform(nextElement)]
}
return reduce (initialValue, combine: step)
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

map with reduce

ﬁlter with reduce

func filterUsingReduce (includeElement: Generator.Element -> Bool) -> [Generator.Element] {
let initialValue = Array()
func step(accumula tedValue: [Generator.Element],
next Element: Generator.Element) -> [Generator .Element] {
guard include Element(nextElement) else {
return acc umulatedValue
}
return accumula tedValue + [nextElement]
}
return reduce(ini tialValue, combine: step)
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

}
}
}

ﬁlter with reduce

Use these?

}
func replaceNegativeSalesWithZero Sales(sales: [Int]) -> [Int] {
return sales.map(negative NumbersToZero)
}
return sales.map(revenuesInDollars ForCopiesSold)
}

View Slide

Easy!

View Slide

return rawSales.mapUsingReduce{$0}
}
func replaceNegativeSalesWithZero Sales(sales: [Int]) -> [Int] {
return sales.mapUsingReduce(negative NumbersToZero)
}
return sales.mapUsingReduce(revenues InDollarsForCopiesSold)
}

View Slide

Still need lots of trolleys

View Slide

Performance is worse

View Slide

Compiler Optimizations

Transducers

One reduce()

Chain steps

Swift solution?

lazy?

transducers?

Nothing yet

Nothing ofﬁcial yet

Search:
transducers in Swift

View Slide

Idea - chain steps in reduce

View Slide

reduce
U, (U, T) -> U

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

This seems confusing

View Slide

Are you sure you
understand this?

View Slide

Not Even
Speaker
Colleagues
Everyone
Parents

View Slide

Not Even
Speaker
Parents

View Slide

transducer
U, (U, T) -> U U, (U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

Start from the last step

View Slide

Use reduce
[USDollars], ([USDollars], NumberOfCopies) -> [USDollars]
revenuesInDollarsForCopiesSold: NumberOfCopies -> USDollars
[NumberOfCopies] -> [USDollars]

Use reduce

Use reduce

Use reduce

Use reduce

Use reduce

Chain in another operation

View Slide

transducer
U,
(U, T) -> U
U,
(U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U,
(U, T) -> U
U,
(U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
U,
(U, T) -> U
U,
(U, S) -> U
f: S -> T
[T] -> U [S] -> U

View Slide

transducer
[USDollars],
([USDollars], T) -> [USDollars]
[USDollars],
([USDollars], S) -> [USDollars]
f: S -> T
[T] -> [USDollars] [S] -> [USDollars]

View Slide

transducer
[USDollars],
([USDollars], T) -> [USDollars]
[USDollars],
f: S -> T
[T] -> [USDollars] [S] -> [USDollars]

View Slide

transducer
[USDollars],
([USDollars], NumberOfCopies)
-> USDollars
[USDollars],
f: S -> NumberOfCopies
[NumberOfCopies] -> [USDollars] [S] -> [USDollars]

View Slide

transducer
[USDollars],
-> USDollars
[USDollars],
reduce with revenueInDollarsForCopiesSold

View Slide

transducer
[USDollars],
-> USDollars
[USDollars],

View Slide

transducer
[USDollars],
-> USDollars
[USDollars],
negativeNumbersToZero:
NumberOfCopies -> NumberOfCopies

View Slide

transducer
[USDollars],
-> USDollars
[USDollars],
Int -> NumberOfCopies

View Slide

transducer
[USDollars],
-> USDollars
[USDollars],
([USDollars], Int) -> [USDollars]
[NumberOfCopies] -> [USDollars] [Int] -> [USDollars]

View Slide

transducer
[USDollars],
-> USDollars
[USDollars],
([USDollars], Int) -> [USDollars]
[NumberOfCopies] -> [USDollars] [Int] -> [USDollars]
reduce implementation of the composition

Ready for the future

Ready for the future

do{iOS} conference

More Decks by do{iOS} conference

Other Decks in Programming

Featured

Transcript