Asynchronous*Programming*in*Swi2 Thomas'Visser,'Highstreet April&21,&2015 

BrightFutures Thomas'Visser,'Highstreet April&21,&2015 

No content

BrightFutures+is+a+simple+Futures+&+ Promises+library+for+iOS+and+OS+X+ wri

func logIn(name: String, pwd: String) -> Future { } 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 } 

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? } } 

Things'that'are'hard'work • error%handling • asynchronous%programming • declaring%data%flow%instead%of%more%state • leveraging%the%power%of%func8onal%concepts 

Things'that'BrightFutures'is'good'for • error%handling • asynchronous%programming • declaring%data%flow%instead%of%more%state • leveraging%the%power%of%func8onal%concepts 

Error$Handling 

Error$Handling var error: NSError? let results = context.executeFetchRequest(request, error: &error) 

Error$Handling let results = context.executeFetchRequest(request, error: nil) 

Error$Handling var error: NSError? let results = context.executeFetchRequest(request, error: &error) 

Error$Handling func fetchProducts(error: NSErrorPointer) -> [Product]? { return (context.executeFetchRequest(request, error: error) as! [Product]) } 

Error$Handling • There's(the(old(way • There's(no((stdlib)(new(way((yet) • Excep9ons(are(gone 

Introducing:,Result 

Introducing:,Result public enum Result { case Success(Box) case Failure(NSError) } 

func fetchProducts() -> Result<[Product]> switch fetchProducts() { case .Success(let boxedProducts): // the products are in boxedProducts.value case .Failure(let error): // something went wrong } 

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) } 

map public enum Result { case Success(Box) case Failure(NSError) public func map(f:T -> U) -> Result } 

map public enum Result { case Success(Box) case Failure(NSError) public func map(f:T -> U) -> Result } func divide(a: Int, b: Int) -> Result let result: Result = divide(13451,22).map { divOut in return divOut % 2 == 0 } 

map public enum Result { case Success(Box) case Failure(NSError) public func map(f:T -> U) -> Result } func divide(a: Int, b: Int) -> Result let result = divide(13451,22).map { divOut in return divide(divOut, 11) } 

map public enum Result { case Success(Box) case Failure(NSError) public func map(f:T -> U) -> Result } func divide(a: Int, b: Int) -> Result let result: Result> = divide(13451,22).map { divOut in return divide(divOut, 11) } 

flatMap public enum Result { case Success(Box) case Failure(NSError) public func map(f:T -> U) -> Result public func flatMap(f:T -> Result) -> Result { } } func divide(a: Int, b: Int) -> Result { } let result: Result = divide(13451,22).flatMap { divOut in return divide(divOut, 11) } 

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 } 

func parseProduct(json: [String:Any]) -> Result { ... } func parseProducts(json: [[String:Any]]) -> Result<[Product]> { let parseResults = json.map { dict in return parseProduct(dict) } return // ?? } 

func parseProduct(json: [String:Any]) -> Result { ... } func parseProducts(json: [[String:Any]]) -> Result<[Product]> { let parseResults: [Result] = json.map { dict in return parseProduct(dict) } return sequence(parseResults) } 

Asynchronous*programming 

Get$off$the$main$thread! —"Sincerely,"UIKit 

// 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() 

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() 

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() 

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() 

Introducing:,Future 

class Future { var result: Result? = nil } 

class Future { var result: Result? = nil func onComplete(callback: Result -> ()) -> Self func onSuccess(callback: T -> ()) -> Self func onFailure(callback: FailureCallback) -> Self } 

class Future { var result: Result? = nil func onComplete(callback: Result -> ()) -> Self func onSuccess(callback: T -> ()) -> Self func onFailure(callback: FailureCallback) -> Self func map(f: (T) -> U) -> Future func flatMap(f: T -> Future) -> Future func flatMap(f: T -> Result) -> Future } 

func dataFromURL(url: String) -> Future 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) } } } 

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) } } } 

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 } 

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 } } 

On#the#Origin#of#Futures 

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 { let p = Promise() Queue.global.async { let nthFib = fibonacci(n) p.success(nthFib) } return p.future } 

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 } 

func execute(request: R) -> Future { let p = Promise() 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 } 

class ImageFetcher { var fetchedImages = [String:Future]() func fetchImage(path: String) -> Future { if !fetchedImages[path] { fetchedImages[path] = actuallyFetchImage(path) } return fetchedImages[path] } private func actuallyFetchImage(path: String) -> Future { // implementation } } 

let products: [Future] = 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) } 

Future • 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 

Thank&you! • BrightFutures:-h.ps:/ /github.com/Thomvis/BrightFutures • Me:-h.ps:/ /twi.er.com/thomvis88 • Highstreet:-h.p:/ /highstreetapp.com