This time Alexander Voronov (@aleks_voronov), iOS Developer at Stanfy talked about Functional Programming 101 with Swift Key points: - Why do we need Functional Programming? - The power of Swift - Functors, Applicatives and Monads - Pipes & Railways - Functional Swift in real life Links Mentioned: - Functors, Applicatives and Monads in Pictures: http://adit.io/posts/2013-04-17-funct... - Railway Oriented Programming: http://fsharpforfunandprofit.com/post... - Functional Programming in Swift (Objc.io): http://www.objc.io/books/fpinswift/ - Moya: https://github.com/Moya/Moya - Argo: https://github.com/thoughtbot/Argo - Swiftz: https://github.com/typelift/Swiftz - RxSwift: https://github.com/ReactiveX/RxSwift - ReactiveCocoa-3.0: https://github.com/ReactiveCocoa/Reac... - Haskell: https://www.haskell.org - F#: http://fsharp.org - Erlang: http://www.erlang.org - Elm: http://elm-lang.org Watch video from the presentation (rus): https://youtu.be/w6zyGylS4Wk Join our MadCode group on FB(rus): https://www.facebook.com/MadCodeMeetup/ Find more videos from MadCode Meetups (rus): https://www.youtube.com/playlist?list=PLrplqd3YJvBvUygFkx4Xvx1p3zyiCgB9Q

1. Stanfy MadCode #9
Alexander Voronov iOS Developer @ Stanfy
https://www.facebook.com/MadCodeMeetup

2. Functional
Programming 101
With Swift

3. What is Functional
Programming?

4. Functional Programming
• Higher-order functions

5. Functional Programming
• Higher-order functions
• Immutable states & pure functions

6. Functional Programming
• Higher-order functions
• Immutable states & pure functions
• Declarative

7. Functional Programming
• Higher-order functions
• Immutable states & pure functions
• Declarative
• Modularity

8. Functional Programming
• Higher-order functions
• Immutable states & pure functions
• Declarative
• Modularity
• Types

9. Swift Power

10. Swift Power
• First Class Functions

11. Swift Power
• First Class Functions
• Currying

12. Swift Power
• First Class Functions
• Currying
• Generics

13. Swift Power
• First Class Functions
• Currying
• Generics
• Type Inference

14. Swift Power
• First Class Functions
• Currying
• Generics
• Type Inference
• Enums

15. First Class Functions
func add(x: Int) -> Int -> Int {
return { y in y + x }
}
let addOne = add(1)
addOne(2)
// 3

16. First Class Functions
func addTwo(x: Int) -> Int {
return x + 2
}
(1...5).map(addTwo)
// [3, 4, 5, 6, 7]

17. Currying
func add(a: Int)(b: Int) -> Int {
return a + b
}
let addOne = add(1)
let xs = 1...5
xs.map(addOne)
// [2, 3, 4, 5, 6]

18. Currying
func curry<A, B, C>(f: (A, B) -> C)
-> A -> B -> C {
return { a in { b in f(a, b) } }
}

19. Generics
func printEach<T: SequenceType>(items: T) {
for item in items {
print(item)
}
}
printEach(1...5)
printEach(["one", "two", "three"])

20. Type Inference
let x = 42.0
x.dynamicType // Double
x is Double // true

21. Type Inference
var xs = [1, 5, 2, 4, 3]
xs.sort(<)
print(xs)
// [1, 2, 3, 4, 5]

22. Type Inference
var xs = [1, 5, 2, 4, 3]
xs.sort(<)
print(xs)
// [1, 2, 3, 4, 5]

23. Type Inference
let xs = [1, 5, 2, 4, 3]
let ys = xs.sorted(<)
print(xs) // [1, 5, 2, 4, 3]
print(ys) // [1, 2, 3, 4, 5]

24. Type Inference
let xs = [1, 5, 2, 4, 3]
let ys = xs.sorted(<)
print(xs) // [1, 5, 2, 4, 3]
print(ys) // [1, 2, 3, 4, 5]

25. Enumerations
enum Fruit: String {
case Apple = "apple"
case Banana = "banana"
case Cherry = "cherry"
}
Fruit.Apple.rawValue
// "apple"

26. Enumerations
enum ValidationResult {
case Valid
case NotValid(NSError)
}

27. Enumerations
enum MyApi {
case xAuth(String, String)
case GetUser(Int)
}
extension MyApi: MoyaTarget {
var baseURL: NSURL { return NSURL(string: "")! }
var path: String {
switch self {
case .xAuth: return "/authorise"
case .GetUser(let id): return "/user/(id)"
}
}
}
https://github.com/Moya/Moya

28. Optionals
enum Optional<T> {
case None
case Some(T)
}
var x = 5
x = nil
// Error!

29. Optional Chaining
struct Dog { var name: String }
struct Person { var dog: Dog? }
let dog = Dog(name: "Dodge")
let person = Person(dog: dog)
let dogName = person.dog?.name

30. Optional Chaining
struct Dog { var name: String }
struct Person { var dog: Dog? }
let dog = Dog(name: "Dodge")
let person = Person(dog: dog)
let dogName = person.dog?.name
Optional Chaining

31. Functors,
Applicatives,
Monads

33. Functors, Applicatives,
Monads
let x = 2
x + 3 // == 5

34. Functors, Applicatives,
Monads
let x = 2
x + 3 // == 5
let y = Optional(2)

35. Functors
let y = Optional(2)
y + 3
// Error!
// Value of optional type
// Optional<Int> not unwrapped

36. Functors
let y = Optional(2)
y.map { $0 + 3 }
// Optional(5)

37. Definition
Optional<T> == T?

38. Functors
func map<U>(f: T -> U) -> Optional<U> {
switch self {
case .Some(let x):
return f(x)
case .None:
return .None
}
}

39. Functors
infix operator <^> {
associativity left
}
func <^> <T, U>(f: T -> U, a: Optional<T>) -> Optional<U> {
return a.map(f)
}

40. Functors
func <^><T, U>(f: T -> U, a: Optional<T>) -> Optional<U> {
return a.map(f)
}
let addOne = { $0 + 1 }
addOne <^> Optional(2) // Optional(3)

41. Functors
func <^><T, U>(f: T -> U, a: Optional<T>) -> Optional<U> {
return a.map(f)
}
let addOne = { $0 + 1 }
addOne <^> Optional(2) // Optional(3)
add <^> Optional(2) <^> Optional(3)

42. Functors
func <^><T, U>(f: T -> U, a: Optional<T>) -> Optional<U> {
return a.map(f)
}
let addOne = { $0 + 1 }
addOne <^> Optional(2) // Optional(3)
add <^> Optional(2) <^> Optional(3)

43. Applicative
func apply<U>(f: Optional<(T -> U)>) -> Optional<U> {
switch f {
case .Some(let someF):
return self.map(someF)
case .None:
return .None
}
}

44. Applicatives
infix operator <*> { associativity left }
func <*><T, U>(f: Optional<(T -> U)>, a: Optional<T>) -> Optional<U> {
return a.apply(f)
}

45. Applicatives
infix operator <*> { associativity left }
func <*><T, U>(f: Optional<(T -> U)>, a: Optional<T>) -> Optional<U> {
return a.apply(f)
}
func add(a: Int)(b: Int) -> Int {
return a + b
}

46. Applicatives
add <^> Optional(2) <*> Optional(3)
// Optional(5)

47. Applicatives
add <^> Optional(2) <*> Optional(3)
// Optional(5)
let a = add <^> Optional(2)

48. Applicatives
add <^> Optional(2) <*> Optional(3)
// Optional(5)
let a = add <^> Optional(2)
let a: (b: Int) -> Optional<Int>

49. Monads
typealias T = Double
let f: T -> T = { $0 * 2.0 }
let g: (T, T) -> T = { $0 / $1 }

50. Monads
typealias T = Double
let f: T -> T = { $0 * 2.0 }
let g: (T, T) -> T = { $0 / $1 }
f(g(4, 2))

51. Monads
typealias T = Double
let f: T -> T = { $0 * 2.0 }
let g: (T, T) -> T = { $0 / $1 }
f(g(4, 2))
g: (T, T) -> Optional<T>

52. Monads
typealias T = Double
let f: T -> T = { $0 * 2.0 }
let g: (T, T) -> T = { $0 / $1 }
f(g(4, 2))
g: (T, T) -> Optional<T>
g(4, 2) >>- { f($0) }

53. Monads
>>-==
http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html

54. Monads
func flatten<U>(a: Optional<Optional<U>>) -> Optional<U> {
switch a {
case .Some(let someA):
return someA
case .None:
return .None
}
}

55. Monads
func flatMap<U>(f: T -> Optional<U>) -> Optional<U> {
return flatten(map(f))
}

56. Monads
func flatMap<U>(f: T -> Optional<U>) -> Optional<U> {
return flatten(map(f))
}
func map<U>(f: T -> U) -> Optional<U>

57. Monads
func flatMap<U>(f: T -> Optional<U>) -> Optional<U> {
return flatten(map(f))
}
func map<U>(f: T -> U) -> Optional<U>

58. Monads
func flatMap<U>(f: T -> Optional<U>) -> Optional<U> {
return flatten(map(f))
}
func map<U>(f: T -> U) -> Optional<U>
func map<Optional<U>>(f: T -> Optional<U>) -> Optional<Optional<U>>

59. Monads
infix operator >>- { associativity left }
func >>-<T, U>(a: Optional<T>, f: T -> Optional<U>) -> Optional<U> {
return a.flatMap(f)
}

60. Monads
func half(a: Int) -> Optional<Int> {
return a % 2 == 0
? a / 2
: .None
}

61. Monads
func half(a: Int) -> Optional<Int> {
return a % 2 == 0
? a / 2
: .None
}
Optional(8) >>- half >>- half
// Optional(2)

62. Monad Laws
• Left Identity
• Right Identity
• Associativity

63. Left Identity Law
let f = { Optional($0 + 1) }
let a = 1
let x = Optional(a) >>- f
let y = f(a)
x == y

64. Right Identity Law
func create<T>(value: T) -> Optional<T> {
return Optional(value)
}
let x = Optional(1) >>- create
let y = Optional(1)
x == y

65. Associativity Law
let double = { Optional(2 * $0) }
let triple = { Optional(3 * $0) }
let x = Optional(1) >>- double >>- triple
let y = Optional(1) >>- { double($0) >>- triple }
let z = { Optional(1) >>- double }() >>- triple
x == y
y == z

66. Recap
Functor
map<U>(f: T -> U) -> M<U>
Applicative
apply<U>(f: M<(T -> U)>) -> M<U>
Monad
flatMap<U>(f: T -> M<U>) -> M<U>

67. Pipes & Railways
@ScottWlaschin

68. Pipes
infix operator |> { associativity left }
public func |> <T, U>(x: T, f: T -> U) -> U {
return f(x)
}
let addTwo = { $0 + 2 }
let prodThree = { $0 * 3 }
5 |> addTwo |> prodThree |> print
// 21

69. Pipes
let transformedX = x
|> addTwo
|> prodThree
|> increment
|> square
|> pow
VS
(pow(square(increment(prodThree(addTwo(x))))))

70. Railways
http://fsharpforfunandprofit.com/posts/recipe-part2/

71. Argo JSON Parser
+
Argo Runes

72. Argo Example
extension Model: Decodable {
static func decode(json: JSON) -> Decoded<Model> {
return Model.create
<^> json <| "id"
<*> json <| "room"
<*> json <| "guest_name"
<*> json <| "status"
<*> json <| "label"
<*> json <|? "user_comment"
<*> json <| ["channel", "label"]
<*> json <| "severity"
<*> json <|| "epochs"
<*> json <|| "body"
}
}

73. Argo Example
let entities: [Model]?
entities = data?.json()
>>- { $0["entities"] }
>>- decode

74. ReactiveCocoa Example
valueLabel.rac_text <~ viewModel.selectedIndex.producer
|> ignoreNil
|> combineLatestWith(viewModel.items.producer)
|> filter { index, items in
index < items.count
}
|> map { index, items in
items[index]
}

75. Where Next?

76. elm-
lang.or
g
www.erlan
g.org
fshar
p.org
https://
www.haskell.or
g
https://github.com/ReactiveCocoa/
ReactiveCocoa
https://github.com/
ReactiveX/RxSwift
https://github.com/
typelift/Swiftz
https://
github.com/
thoughtbot/Argo
www.objc.io/books/fpinswift/
fsharpforfunandprofit.com/posts/recipe-part2/
adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html
Where Next
• Functors, Applicatives and Monads in Pictures
• Railway Oriented Programming
• Functional Programming in Swift (Objc.io)
• Argo
• Swiftz
• RxSwift
• ReactiveCocoa-3.0
• Haskell, F#, Erlang, Elm

77. Thanks!

78. Comments / Questions?
@aleks_voronova-voronov