Asynchronous Programming in Swift / BrightFutures

I gave this talk at the CocoaHeadsNL meetup in April 2015. It gives an introduction to BrightFutures (https://github.com/Thomvis/BrightFutures), my open source futures & promises implementation in Swift.

Transcript

1. Asynchronous*Programming*in*Swi2 Thomas'Visser,'Highstreet April&21,&2015
2. BrightFutures Thomas'Visser,'Highstreet April&21,&2015
4. BrightFutures+is+a+simple+Futures+&+ Promises+library+for+iOS+and+OS+X+ wri<en+in+Swi=. —"README.md
5. func logIn(name: String, pwd: String) -> Future<User> { } func fetchPosts(user: User) -> Future<[Post]> { } logIn(username,password).flatMap { user in fetchPosts(user) }.onSuccess { posts in // do something with the user's posts }.onFailure { error in // either logging in or fetching posts failed }
6. logInWithCompletionHandler { (user: User?, error: NSError?) in if let user = user { fetchPostsWithCompletionHander(user) { posts, error in if let posts = posts { // hurray, do something with the posts } else if let error = error { // could not fetch posts, at least we have the user } else { // can this happen? } } } else if let error = error { // something went wrong } else { // can this happen? } }
7. Things'that'are'hard'work • error%handling • asynchronous%programming • declaring%data%flow%instead%of%more%state • leveraging%the%power%of%func8onal%concepts
8. Things'that'BrightFutures'is'good'for • error%handling • asynchronous%programming • declaring%data%flow%instead%of%more%state • leveraging%the%power%of%func8onal%concepts
9. Error$Handling
10. Error$Handling var error: NSError? let results = context.executeFetchRequest(request, error: &error)
11. Error$Handling let results = context.executeFetchRequest(request, error: nil)
12. Error$Handling var error: NSError? let results = context.executeFetchRequest(request, error: &error)
13. Error$Handling func fetchProducts(error: NSErrorPointer) -> [Product]? { return (context.executeFetchRequest(request, error: error) as! [Product]) }
14. Error$Handling • There's(the(old(way • There's(no((stdlib)(new(way((yet) • Excep9ons(are(gone
15. Introducing:,Result<T>
16. Introducing:,Result<T> public enum Result<T> { case Success(Box<T>) case Failure(NSError) }
17. func fetchProducts() -> Result<[Product]> switch fetchProducts() { case .Success(let boxedProducts): // the products are in boxedProducts.value case .Failure(let error): // something went wrong }
18. func fetchProducts() -> Result<[Product]> { var error: NSError? let products: [AnyObject]? = context.executeFetchRequest(request, error: &error) if let products = products as? [Product] { return .Success(Box(products)) } if error { return .Failure(error) } return .Failure(MissingDataError) }
19. map public enum Result<T> { case Success(Box<T>) case Failure(NSError) public func map<U>(f:T -> U) -> Result<U> }
20. map public enum Result<T> { case Success(Box<T>) case Failure(NSError) public func map<U>(f:T -> U) -> Result<U> } func divide(a: Int, b: Int) -> Result<Int> let result: Result<Bool> = divide(13451,22).map { divOut in return divOut % 2 == 0 }
21. map public enum Result<T> { case Success(Box<T>) case Failure(NSError) public func map<U>(f:T -> U) -> Result<U> } func divide(a: Int, b: Int) -> Result<Int> let result = divide(13451,22).map { divOut in return divide(divOut, 11) }
22. map public enum Result<T> { case Success(Box<T>) case Failure(NSError) public func map<U>(f:T -> U) -> Result<U> } func divide(a: Int, b: Int) -> Result<Int> let result: Result<Result<Int>> = divide(13451,22).map { divOut in return divide(divOut, 11) }
23. flatMap public enum Result<T> { case Success(Box<T>) case Failure(NSError) public func map<U>(f:T -> U) -> Result<U> public func flatMap<U>(f:T -> Result<U>) -> Result<U> { } } func divide(a: Int, b: Int) -> Result<Int> { } let result: Result<Int> = divide(13451,22).flatMap { divOut in return divide(divOut, 11) }
24. func jsonFromResponseData(responseData: NSData) -> Result<[[String:Any]]> { ... } func parseProducts(json: [[String:Any]]) -> Result<[Product]> { ... } let productResult = jsonFromResponseData(data).flatMap { json in return parseProducts(json) } if let products = productResult.value { // do something with the products }
25. func parseProduct(json: [String:Any]) -> Result<Product> { ... } func parseProducts(json: [[String:Any]]) -> Result<[Product]> { let parseResults = json.map { dict in return parseProduct(dict) } return // ?? }
26. func parseProduct(json: [String:Any]) -> Result<Product> { ... } func parseProducts(json: [[String:Any]]) -> Result<[Product]> { let parseResults: [Result<Product>] = json.map { dict in return parseProduct(dict) } return sequence(parseResults) }
27. Asynchronous*programming
28. Get$off$the$main$thread! —"Sincerely,"UIKit
29. // here's the definition: func dataTaskWithURL( url: NSURL, completion: ((NSData!, NSURLResponse!, NSError!) -> Void)? ) -> NSURLSessionDataTask // let's use it: session.dataTaskWithURL("http://bit.ly/1IPyYmP") { data, response, error in if error != nil { // something went wrong } else { // we can more or less safely use data and response now } }.resume()
30. session.dataTaskWithURL("http://bit.ly/1IPyYmP") { result in switch result { case .Success(let box): // safe access to access box.value.0 and box.value.1 case .Failure(let error): // something went wrong } }.resume()
31. session.dataTaskWithURL("http://bit.ly/1IPyYmP") { (result: Result<(NSData,NSURLResponse)>) in switch result { case .Success(let box): // safe access to access box.value.0 and box.value.1 case .Failure(let error): // something went wrong } }.resume()
32. session.dataTaskWithURL("http://bit.ly/1IPyYmP") { result in if let (data, response) = result.value { jsonFromResponseData(data).flatMap { (json: [[String:Any]]) in return parseProducts(json) }.map { (products: [Product]) in for product in products { session.dataTaskWithURL(product.url) { result in // fetch something for each product }.resume() } // do something when all product.url's have been loaded? } } else { // something went wrong } }.resume()
33. Introducing:,Future<T>
34. class Future<T> { var result: Result<T>? = nil }
35. class Future<T> { var result: Result<T>? = nil func onComplete(callback: Result<T> -> ()) -> Self func onSuccess(callback: T -> ()) -> Self func onFailure(callback: FailureCallback) -> Self }
36. class Future<T> { var result: Result<T>? = nil func onComplete(callback: Result<T> -> ()) -> Self func onSuccess(callback: T -> ()) -> Self func onFailure(callback: FailureCallback) -> Self func map<U>(f: (T) -> U) -> Future<U> func flatMap<U>(f: T -> Future<U>) -> Future<U> func flatMap<U>(f: T -> Result<U>) -> Future<U> }
37. func dataFromURL(url: String) -> Future<NSData> let res = dataFromURL("http://bit.ly/1IPyYmP").flatMap { (data:NSData) in return jsonFromResponseData(data) }.flatMap { json in return parseProducts(json) }.flatMap { products: [Products] in return products.map { product in return dataFromURL(product.url).map { (data:NSData) in return (product, data) } } }
38. let res: [Future<(Product,NSData)>] = dataFromURL("http://bit.ly/1IPyYmP").flatMap { (data:NSData) in return jsonFromResponseData(data) }.flatMap { json in return parseProducts(json) }.flatMap { products: [Products] in return products.map { product in return dataFromURL(product.url).map { (data:NSData) in return (product, data) } } }
39. let res: [Future<(Product,NSData)>] = dataFromURL("http://bit.ly/1IPyYmP").flatMap { (data:NSData) in return jsonFromResponseData(data) }.flatMap { json in return parseProducts(json) }.flatMap { products: [Products] in return products.map { product in return dataFromURL(product.url).map { (data:NSData) in return (product, data) } } } sequence(res).onSuccess { (pd:[(Product, Data)]) in // do something with the products and their data }.onFailure { error in // something failed: // - retrieving bit.ly URL // - turning data into JSON // - turning JSON into products // - fetching additional data from the product's url }
40. let res: [Future<(Product,NSData)>] = dataFromURL("...").flatMap { (data:NSData) in return jsonFromResponseData(data) }.flatMap { json in return parseProducts(json) }.flatMap { products: [Products] in return products.map { product in return dataFromURL(product.url).map { (data:NSData) in return (product, data) } } } sequence(res).onSuccess { (pd:[(Product, Data)]) in // do something with the products and their data }.onFailure { error in if let (product, data) = res.first?.value { // the first product did load, recover from the error by doing something with it } }
41. On#the#Origin#of#Futures
42. func fibonacci(n: Int) -> Int { switch n { case 0...1: return n default: return fibonacci(n - 1) + fibonacci(n - 2) } } func asyncFibonacci(n: Int) -> Future<Int> { let p = Promise<Int>() Queue.global.async { let nthFib = fibonacci(n) p.success(nthFib) } return p.future }
43. future { // runs on a background thread (GCD's global queue) fibonacci(1000) }.onSuccess { i in // called on the main thread // i is the 1000th Fibonacci number }
44. func execute<R: ParentAppRequest>(request: R) -> Future<R.ResponseType> { let p = Promise<R.ResponseType>() let sent = WKInterfaceController.openParentApplication(request.userInfo, reply: { (response, error) -> Void in if let error = error { p.failure(error) } else { p.complete(request.parseResponse(response)) } }) if !sent { p.failure(InfrastructureError.ParentAppCommunicationFailure.NSErrorRepresentation) } return p.future }
45. class ImageFetcher { var fetchedImages = [String:Future<UIImage>]() func fetchImage(path: String) -> Future<UIImage> { if !fetchedImages[path] { fetchedImages[path] = actuallyFetchImage(path) } return fetchedImages[path] } private func actuallyFetchImage(path: String) -> Future<UIImage> { // implementation } }
46. let products: [Future<Product>] = fetchProducts().recover { error in return retrieveProductsFromCache() } let sumPrice = FutureUtils.fold(products, zero: 0) { sum, product in return sum + product.price } let token = InvalidationToken() Queue.global.after(.In(2.0)) { token.invalidate() } products.zip(sumPrice).map(context: Queue.global.context) { products, sumPrice in // we're on the global queue here return sumPrice / products.count }.onSuccess(token: token) { averagePrice in // safely update the UI label.setText(averagePrice) }
47. Future<BrightFutures> • Release'1.0.0 • Produc1on'usage • Integra1on'with'CocoaTouch'/'3rd'party'libs • FutureProofing:'hCps:/ /github.com/Thomvis/FutureProofing' • Progress'&'cancella1on:' • GoodProgress:'hCps:/ /github.com/Thomvis/GoodProgress
48. Thank&you! • BrightFutures:-h.ps:/ /github.com/Thomvis/BrightFutures • Me:-h.ps:/ /twi.er.com/thomvis88 • Highstreet:-h.p:/ /highstreetapp.com