TYPE DRIVEN DEVELOPMENT IN SWIFT @JOHANNESWEISS || [email protected] 

TDD? 

TYDD! 

KEY STRATEGIES & BENEFITS ▸ laying out the types first ! rapid prototyping & easy refactoring ▸ preferring compiler proof to unit test ! correctness & quicker ▸ reducing side-effects ! enable (unit) testing & composability 

MAKING THE ILLEGAL IMPOSSIBLE ! ALLOWING THE COMPILER TO HELP AS MUCH AS POSSIBLE 

BAD EXAMPLE struct BookStatusBad { let available : Bool let lost : Bool let lentTo : Person? } illegal values: let ill1 = BookStatusBad(available: true, lost: true, lentTo: TimCook) let ill2 = BookStatusBad(available: true, lost: false, lentTo: TimCook) let ill3 = BookStatusBad(available: false, lost: false, lentTo: nil) 

BETTER enum BookStatus { case Available case Lost case LentTo(Person) } ▸ Goal: Only meaningful values can be created. 

BAD EXAMPLE func contentsOfDirectoryAtPath(path : String) -> ([String]?, NSError?) { [...] } WHY BAD? ▸ illegal values (nil, nil) & ([...], NSError(...)) 

BETTER! enum Result { case Success(T) case Failure(NSError) } func contentsOfDirectoryAtPath(path : String) -> Result<[String]> func createDirectoryAtPath(path : String) -> Result<()> func dataWithJSONObject(obj : AnyObject) -> Result * COMPILER BUGS CURRENTLY PREVENT THIS 

TEMPORARY WORKAROUND class Box { let unbox : T init(_ value: T) { self.unbox = value } } enum Result { case Failure(NSError) case Success(Box) init(Success value:T) { self = .Success(Box(value)) } init(Failure error:NSError) { self = .Failure(error) } } 

RESULT COALESCING OPERATOR func ??(result: Result, @autoclosure defaultValue: () -> T) -> T { switch result { case .Success(let boxedValue): return boxedValue.unbox case .Failure(let _): return defaultValue() } } print(Result(Success:"Hello ") ?? "foo") print(Result(Failure: someError) ?? "World!\n") 

MAPPING extension Result { func map(f: T -> A) -> Result { switch self { case .Success(let boxedValue): return Result(Success: f(boxedValue.unbox)) case .Failure(let problem): return Result(Failure: problem) } } } print(Result(Success:966).map { $0 / 42 }) /* Result(Success: 23) */ 

WHEN DESIGNING TYPE FIRST, YOU OFTEN HAVE TO (TEMPORARILY) FILL HOLES ⛳️ 

UNDEFINED CAN FILL HOLES func undefined(_ message:String="") -> T { fatalError("undefined \(message)") } Can be used for simple things like let a : String = undefined("special string") let b : Int = undefined("some int") let t = NSTimer(timeInterval: undefined(), target: undefined(), selector: undefined(), userInfo: undefined(), repeats: undefined()) 

FUNCTION HOLES func parseIntFromString(input : String) -> Int? { let parsedInt = (undefined() as String -> Int?)(input) return parsedInt } func mayFail(x : Int) -> Result func addUpSuccesses(xs : [Int]) -> Int { let combine : (Int, Result) -> Int = undefined("fancy +") return map(xs, mayFail).reduce(0, combine:combine) } -> fatal error: undefined fancy +: file main.swift, line 214 

CONCENTRATING ON SUCCESS FIRST func rm(path:String) -> Result<()> { if NSFileManager.defaultManager().removeItemAtPath(path, error:undefined("NSError pointer")) { return Result(Success:()) } else { return Result(Failure:undefined("the NSError returned above")) } } 

HANDLING THE IMPOSSIBLE func lexicographicallyLowestString(x:String, y:String, z:String) -> String { let xyz = [x, y, z] return xyz.sorted({ $0 < $1 }).first ?? undefined("the impossible happened!") } 

! PHANTOMS 

PHANTOM TYPES protocol Currency {} enum GBP : Currency {} enum EUR : Currency {} enum USD : Currency {} struct Money { let amount : NSDecimalNumber } 

PHANTOM TYPE EXAMPLE func convertGBPtoEUR(gbp:Money) -> Money { let forex : NSDecimalNumber = NSDecimalNumber(mantissa: 133263, exponent: -5, isNegative: false) return Money(amount:gbp.amount.decimalNumberByMultiplyingBy(forex)) } 

THANK YOU! @JOHANNESWEISS || [email protected] || GITHUB.COM/WEISSI