THE FUNCTIONAL
WAY
@NATASHATHEROBOT

"functional programming is a
programming paradigm... that treats
computation as the evaluation of
mathematical functions and avoids
changing-state and mutable data."
Wikipedia

"A mathematical function is a function
that when you give it the same
argument, it will give you the same
result" - Edx FP101x

▸ computation as the evaluation of mathematical functions
▸ avoid changing state
▸ avoid mutable data

NO SIDE EFFECTS

let numbers = Array(1...10)
var total = 0
func addNumbers() {
for number in numbers {
total += number
}
}

addNumbers()
total // 55
addNumbers()
total // 110
addNumbers()
total // 165

let myNumbers = Array(1...10)
var total = addNumbers(myNumbers)
func addNumbers(numbers: [Int]) -> Int {
// can also be written shorthand as
// numbers.reduce(0,+)
return numbers.reduce(0) { (sum, number) in sum + number }
}

total = addNumbers(myNumbers) // 55
total = addNumbers(myNumbers) // 55
total = addNumbers(myNumbers) // 55

import Foundation
class Gift {
let recipient: String
let item: String
let budget: NSDecimalNumber
let status: Status
enum Status: String {
case Purchased = "Purchased"
case Wrapped = "Wrapped"
case Delivered = "Delivered"
}
init(recipient: String,
item: String,
budget: NSDecimalNumber,
status: Status)
{
self.recipient = recipient
self.item = item
self.budget = budget
self.status = status
}
}

extension Gift {
func todo() -> String {
switch status {
case .Purchased:
return "Wrap it!"
case .Wrapped:
return "Mail it!"
case .Delivered:
return "Relax and drink some eggnog :)"
}
}
}

extension Gift {
func todo(fromStatus status: Status) -> String {
switch status {
case .Purchased:
return "Wrap it!"
case .Wrapped:
return "Mail it!"
case .Delivered:
return "Relax and drink some eggnog :)"
}
}
}

class GiftTests: XCTestCase {
func testTodo_Purchased() {
let gift = Gift(
recipient: "My Cousin Julie,
item: "GoldieBlox",
budget: NSDecimalNumber(double: 20.00),
status: .Purchased)
XCTAssertEqual(gift.todo(), "Wrap it!")
}
func testTodo_Wrapped() {
let gift = Gift(
recipient: "My Cousin Julie",
item: "GoldieBlox",
budget: NSDecimalNumber(double: 20.00),
status: .Wrapped)
XCTAssertEqual(gift.todo(), "Mail it!")
}
func testTodo_Delivered() {
let gift = Gift(
recipient: "My Cousin Julie",
item: "GoldieBlox",
budget: NSDecimalNumber(double: 20.00),
status: .Delivered)
XCTAssertEqual(gift.todo(), "Relax and drink some eggnog :)")
}
}

import XCTest
class GiftTests: XCTestCase {
let gift = Gift(
recipient: "My Cousin Tommy",
item: "Choo Choo Train",
budget: NSDecimalNumber(double: 20.00),
status: .Purchased)
func testTodo_Purchased() {
XCTAssertEqual(gift.todo(fromStatus: .Purchased), "Wrap it!")
}
func testTodo_Wrapped() {
XCTAssertEqual(gift.todo(fromStatus: .Wrapped), "Mail it!")
}
func testTodo_Delivered() {
XCTAssertEqual(gift.todo(fromStatus: .Delivered), "Relax and drink some eggnog :)")
}
}

import XCTest
class GiftTests: XCTestCase {
func testTodo_Purchased() {
XCTAssertEqual(Gift.todo(fromStatus: .Purchased), "Wrap it!")
}
func testTodo_Wrapped() {
XCTAssertEqual(Gift.todo(fromStatus: .Wrapped), "Mail it!")
}
func testTodo_Delivered() {
XCTAssertEqual(Gift.todo(fromStatus: .Delivered), "Relax and drink some eggnog :)")
}
}

VALUE TYPES

"Almost all types in Swift are value
types, including arrays, dictionaries,
numbers, booleans, tuples, and enums.
Classes are the exception rather than
the rule." - Functional Swift Book

NSError *err = nil;
CGFloat result = [MYArithmetic divide:2.5 by:3.0 error:&err];
if (err) {
NSLog(@"%@", err)
} else {
[MYArithmetic doSomethingWithResult:result]
}
@nomothetis

enum Result {
case Success(AnyObject)
case Failure(NSError)
}
@nomothetis

let result = MYArithmetic.divide(2.5, by:3)
switch result {
case Success(let quotient):
doSomethingWithResult(quotient)
case Failure(let error):
handleError(error)
}
@nomothetis

http://nomothetis.svbtle.com/error-handling-in-swift

CURRYING

func add(x: Int, y: Int) -> Int {
return x + y
}
add(2, 3) // 5

func add(x: Int) -> Int -> Int {
return { y in return x + y }
}
let partialAdd = add(2)
// let addFunc: (Int -> Int)
let sum = partialAdd(3)
// 5
let arr = [1,2,3]
let incrementBy2 = arr.map(partialAdd)
// [3,4,5]
add(6)(4)
// 10

func add(#x: Int)(y: Int) -> Int {
return x + y
}
add(x: 2)(y: 3)
// 5

struct Logger {
/// Level of log message to aid in the filtering of logs
enum Level: Int, Printable {
/// Messages intended only for debug mode
case Debug = 3
/// Messages intended to warn of potential errors
case Warn = 2
/// Critical error messages
case Error = 1
/// Log level to turn off all logging
case None = 0
var description: String {
switch(self) {
case .Debug:
return "Debug"
case .Warn:
return "Warning"
case .Error:
return "Error"
case .None:
return ""
}
}
}
}
@drewag

extension Logger {
/// What is the max level to be logged
///
/// Any logs under the given log level will be ignored
static var logLevel: Level = .Warn
/// Log a message to the console
static func log
(#level: Level)
(name: String)
(message: String) -> String
{
if level.rawValue <= Logger.logLevel.rawValue {
return "(level.description): (name) - (message)"
}
return ""
}
}
@drewag

Logger.log(level: .Debug)(name: "MyFunction")(message: "Is this being called?")
// Debug: MyFunction - Is this being called?

extension Logger {
/// Logger for debug messages
static var debug = Logger.log(level: .Debug)
// static var debug: (name: String) -> (message: String) -> String
/// Logger for warnings
static var warn = Logger.log(level: .Warn)
/// Logger for errors
static var error = Logger.log(level: .Error)
}
@drewag

Logger.logLevel = .Debug
func myFunctionToDebug() {
var x = 5
// do something to x
Logger.debug(name: "myFunctionToDebug")(message: "x: (x)")
}
myFunctionToDebug()
// Prints: "Debug: myFunctionToDebug - x: 10"
@drewag

func myFunctionToDebug() {
var x = 5
var y = 3
// do something to x
// do something to y
let debugMyFunction = Logger.debug(name: "myFunctionToDebug")
debugMyFunction(message: "x: (x)")
debugMyFunction(message: "y: (y)")
}
myFunctionToDebug()
// Prints: "Debug: myFunctionToDebug - x: 10"
// Prints: "Debug: myFunctionToDebug - y: 13"

http://drewag.me/posts/practical-use-for-curried-functions-in-swift

TYPE-DRIVEN
DESIGN

func credits(account: Account) -> Int {
// ask data source for account credits
return credits
}
@FunctionalSwift

typealias Credits = Int
func credits(account: Account) -> Credits {
// ask data source for amount of credits
return amount
}
@FunctionalSwift

"One important lesson I've learned is
that designing the right types for your
problem is a great way to help the
compiler debug your program." -
@wouterswierstra

struct Credits { let amount: Int }
func credits(account: Account) -> Credits {
// ask data source for amount of credits
return Credits(amount: amount)
}
@FunctionalSwift

let myCredits = credits(myAccount)
myCredits + 1 // ERROR
// Cannot invoke '+' with an argument of type
// '(Credit, IntegerLiteralConvertable)'

http://www.objc.io/snippets/8.html
http://www.swiftcast.tv/articles/the-design-of-types

RESOURCES
▸ Functional Swift Book
▸ Edx FP101x
▸ Functional Snippets
▸ An Introduction to Haskell - Skills Matter
▸ swiftnews.curated.co

QUESTIONS?
@NATASHATHEROBOT