Swift Lille Meetup #2 - @CallMeSH - How to use the result type to handle errors in Swift 5 ?

Transcript

1. Swift 5's Result<T,E> Type Swift Lille Meetup 2
2. The Swift error handling model
3. A function throws func divide(_ divident: Float, _ divider: Float) throws -> Float { if divider == 0 { throw DivisionError.illegalDivider } return divident / divider }
4. The call must be tried — do try catch — try? — try! ! do { let result = try divide(50.0, 0.0) print("The result is: \(result)") } catch let error { print("An error happened: \(error.localizedDescription)") }
5. The Swift error handling model — Pros: — Easy to use — Helped by the compiler — Cons: — The Error is not type safe — How do you handle asynchronous errors ?
6. Can an asynchronous function throw? func fetchProducts(handler: @escaping (() throws -> [Product]) -> Void) { let request = URLRequest(url: URL(string:"https://mystore.com/products")!) URLSession.shared.dataTask(with: request) { (data, response, error) in if let error = error { handler { throw error } } if let data = data { handler { return try decoder.decode([Product].self, from: data) } } } } fetchProducts { (getResult) in do { let products = try getResult() print("Here is my list of products:") print(products) } catch let error { print("An error happened: \(error.localizedDescription)") } }
7. Can an asynchronous function throw? — They can, but that makes the code complicated... — Still not type safe...
8. The Result type
9. They come in all shapes and forms... enum Result<Type, ErrorType> { case success(Type) case failure(ErrorType) }
10. How do you use it? func fetchProducts(handler: @escaping (Result<[Product], FetchProductError>) -> Void ) { let request = URLRequest(url: URL(string:"https://mystore.com/products")!) URLSession.shared.dataTask(with: request) { (data, response, error) in if let error = error { handler(.failure(.networkError(error))) } if let data = data { do { let products = try decoder.decode([Product].self, from: data) handler(.success(products)) } catch let error { handler(.failure(.parsingError(error))) } } } }
11. fetchProducts { (result) in switch result { case let .success(products): print("The products are:") print(products) case .failure(.networkError): print("A network error happened!") case .failure(.parsingError): print("A parsing error happened!") } }
12. Result Type — Pros: — Removes the ambiguity of (data: Data?, error: Error?) — The error type is safe — Easier than the async throwing — Cons: — How do you bridge between implementations?
13. Swift 5 makes it part of the standard library
14. A few functional highlights // Returns a new result, mapping any success value using the given transformation. func map<NewSuccess>((Success) -> NewSuccess) -> Result<NewSuccess, Failure> // Returns a new result, mapping any failure value using the given transformation. func mapError<NewFailure>((Failure) -> NewFailure) -> Result<Success, NewFailure> // Returns a new result, mapping any success value using the given transformation and unwrapping the produced result. func flatMap<NewSuccess>((Success) -> Result<NewSuccess, Failure>) -> Result<NewSuccess, Failure> // Returns a new result, mapping any failure value using the given transformation and unwrapping the produced result. func flatMapError<NewFailure>((Failure) -> Result<Success, NewFailure>) -> Result<Success, NewFailure>
15. This allows chaining func fetchProducts(handler: @escaping (Result<Data, FetchProductError>) -> Void ) { let request = URLRequest(url: URL(string:"https://mystore.com/products")!) URLSession.shared.dataTask(with: request) { (data, response, error) in if let error = error { handler(.failure(.networkError(error))) } if let data = data { handler(.success(data)) } } } fetchProducts { (result) in let data = result print(data) }
16. This allows chaining func parseProducts(_ data: Data) -> Result<[Product], FetchProductError> { do { let products = try decoder.decode([Product].self, from: data) return .success(products) } catch let error { return .failure(.parsingError(error)) } } func getFirst<T>(_ data: [T]) -> T? { return data.first }
17. This allows chaining fetchProducts { (result) in let firstProduct = result .flatMap(parseProducts) .map(getFirst) print(firstProduct) }
18. You can also bridge from the standard error model func parseProducts(_ data: Data) -> Result<[Product], FetchProductError> { do { let products = try decoder.decode([Product].self, from: data) return .success(products) } catch let error { return .failure(.parsingError(error)) } }
19. You can also bridge from the standard error model func parseProducts(_ data: Data) -> Result<[Product], FetchProductError> { return Result { try decoder.decode([Product].self, from: data)} .mapError { FetchProductError.parsingError($0) } }
20. When can I use it?!
21. It depends... — You are using libraries? You'll have to wait for them — Alamofire is almost ready — So is PromiseKit — ... — Not using livraries? — Install Xcode 10.2, you're good to go!
22. What's next?
23. Result is the step 1 — Expect Foundation to adapt soon — Swift 6 or 7 will bring Coroutines (async/await)
24. Thank you!
25. Charles-Henri DUMALIN — @CallMeSH — charles-henri@mobiten.com — mobiten.com Come and talk to me!