Advanced functional programing in Swift

Vincent Pradeilles - CocoaHeads Lyon - 21/09/17
Advanced functional
programming
Pragmatic use cases for Monads

Functional Programming

First-class and higher-order functions
let double: (Int) -> Int = { $0 * 2 }
func apply(value: Int, function: (Int) -> Int) -> Int {
return function(value)
}
let result = apply(value: 4, function: double)
// result == 8

Some properties
• A function is said to be pure if it produces no side-effects and its
return value only depends on its arguments
• An expression is said to be referentially transparent if it can be
replaced by its value without altering the program’s behavior

Optionals

Some very familiar code
var data: [String]?
// ...
let result = data?.first?.uppercased()

Some very familiar code
var data: [String]?
// ...
let result = data?.first?.uppercased()
The operator ?. allows us to declare a workﬂow that will be executed
in order, and will prematurely stop if a nil value is encountered

Let’s try to write the code for ?.
extension Optional {
func ?.<U>(lhs: Wrapped?, rhs: (Wrapped) -> U) -> U? {
switch self {
case .some(let value):
return .some(rhs(value))
case .none:
return nil
}
}
}
Disclaimer : this is a simpliﬁed
case for methods with no
arguments

Arrays

Let’s manipulate an Array
let data: [Int] = [0, 1, 2]
let result = data.map { $0 * 2 }.map { $0 * $0 }

Let’s manipulate an Array
let data: [Int] = [0, 1, 2]
let result = data.map { $0 * 2 }.map { $0 * $0 }
Same thing here: the function map allows us to declare a workﬂow

A possible implementation for map
extension Array {
func map<U>(_ transform: (Element) -> U) -> [U] {
var result: [U] = []
for e in self {
result.append(transform(e))
}
return result
}
}

Functions

Let’s compose functions
let double: (Int) -> Int = { x in x * 2 }
let square: (Int) -> Int = { x in x * x }
infix operator • : AdditionPrecedence
func •<T, U, V>(lhs: (U) -> V, rhs: (T) -> U) -> ((T) -> V) {
return { t in lhs(rhs(t)) }
}
let result = (double • square)(4) // result == 32
Disclaimer : @escaping
attributes have been omitted

Let’s compose functions
let double: (Int) -> Int = { x in x * 2 }
let square: (Int) -> Int = { x in x * x }
infix operator • : AdditionPrecedence
func •<T, U, V>(lhs: (U) -> V, rhs: (T) -> U) -> ((T) -> V) {
return { t in lhs(rhs(t)) }
}
let result = (double • square)(4) // result == 32

We have three similar behaviors,
yet backed by very different
implementation

What are the common parts?
• They contain value(s) inside a context
• They add new features to existing types
• They provide an interface to transform/map the inner value

Monad: intuitive deﬁnition
• Wraps a type inside a context
• Provides a mechanism to create a workﬂow of transforms

Minimal Monad
struct Monad<T> {
let value: T
// additional data
static func just(_ value: T) -> Monad<T> {
return self.init(value: value)
}
}
infix operator >>> : AdditionPrecedence
func >>> <U, V>(lhs: Monad<U>, rhs: (U) -> Monad<V>) -> Monad<V> {
// specific combination code
}

Let’s look at an application

Writer Monad
• We have an application that does a lot of numerical calculation
• It’s hard to keep track of how values have been computed
• We would like to have a way to store a value along with a log of all
the transformation it went through

Writer Monad
struct Logged<T> {
let value: T
let logs: [String]
private init(value: T) {
self.value = value
self.logs = ["initialized with value: (self.value)"]
}
static func just(_ value: T) -> Logged<T> {
return Logged(value: value)
}
}
func >>> <U, V>(lhs: Logged<U>, rhs: (U) -> Logged<V>) -> Logged<V> {
let computation = rhs(lhs.value)
return Logged<V>(value: computation.value, logs: lhs.logs + computation.logs)
}

Writer Monad
func square(_ value: Int) -> Logged<Int> {
let result = value * value
return Logged(value: result, log: "(value) was squared, result: (result)")
}
func halve(_ value: Int) -> Logged<Int> {
let result = value / 2
return Logged(value: result, log: "(value) was halved, result: (result)")
}

Writer Monad
let computation = .just(4) >>> square >>> halve
print(computation)
// Logged<Int>(value: 8, logs: ["initialized with value: 4",
"4 was squared, result: 16", "16 was halved, result: 8"])

Now let’s think architecture

We can model the current state of an app with a struct
struct AppState {
let userName: String
let currentSong: URL?
let favoriteSongs: [URL]
}

We can model the action our app emits, in a declarative fashion
protocol Action { }
struct UpdateUserNameAction: Action {
let newUserName: String
}

We can react to those actions in a functional way
infix operator >>> : AdditionPrecedence
func >>>(appstate: AppState?, action: Action) -> AppState {
var appstate = appstate ?? AppState()
switch action {
case let newUserNameAction as UpdateUserNameAction:
appstate.userName = newUserNameAction.newUserName
default:
break
}
return appstate
}

And ﬁnally we put everything together
AppState() >>> UpdateUserNameAction(newUserName: "Vincent")
// AppState(userName: Optional("Vincent"), currentSong: nil,
favoriteSongs: [])

ReSwift

Minimal example
import ReSwift
struct AppState: StateType {
// ... app state properties here ...
}
func appReducer(action: Action, state: AppState?) -> AppState {
// ...
}
let store = Store(
reducer: appReducer,
state: AppState(), // You may also start with `nil`
middleware: []) // Middlewares are optional

A more « real life » example
func appReducer(action: Action, state: AppState?) -> AppState {
return AppState(
navigationState: navigationReducer(state?.navigationState, action: action),
authenticationState: authenticationReducer(state?.authenticationState, action: action),
repositories: repositoriesReducer(state?.repositories, action: action),
bookmarks: bookmarksReducer(state?.bookmarks, action: action)
)
}

func authenticationReducer(state: AuthenticationState?, action: Action) -> AuthenticationState {
var state = state ?? initialAuthenticationState()
switch action {
case _ as ReSwiftInit:
break
case let action as SetOAuthURL:
state.oAuthURL = action.oAuthUrl
case let action as UpdateLoggedInState:
state.loggedInState = action.loggedInState
default:
break
}
return state
}

let store: Store<AppState> = Store(reducer: appReducer, state: nil) // in AppDelegate file
class BookmarksViewController: UIViewController, StoreSubscriber {
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
store.subscribe(self) { subcription in
return subcription.select { state in return state.bookmarks }
}
}
override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
store.unsubscribe(self)
}
func newState(state: StateType?) {
// update view
}
}

Advantages
• Reducers are pure (stateless) functions, easy to test
• Code review of business logic is easier
• A « demo » mode of the app is easy to implement (UI Testing)
• Deep-linking becomes a trivial use-case

Drawbacks
• Not a silver bullet, a bit overkill for web-service driven apps
• Requires to create a lot of types (but at least not ObjC types)

Questions ?

Bibliography
• https://en.wikipedia.org/wiki/Monad_(functional_programming)
• https://www.youtube.com/watch?v=ZhuHCtR3xq8 (Brian Beckman: Don't fear
the Monad)
• https://academy.realm.io/posts/slug-raheel-ahmad-using-monads-functional-
paradigms-in-practice-functors-patterns-swift/ (Using Monads and Other
Functional Paradigms in Practice)
• https://github.com/orakaro/Swift-monad-Maybe-Reader-and-Try
• https://academy.realm.io/posts/benji-encz-unidirectional-data-ﬂow-swift/
(Unidirectional Data Flow: Shrinking Massive View Controllers)

Advanced functional programing in Swift

More Related Content

What's hot

Viewers also liked

Similar to Advanced functional programing in Swift

More from Vincent Pradeilles

Recently uploaded

Advanced functional programing in Swift