Result Oriented Development

When I last talked about functional programming, we saw by using small, micro functions, a nasty, complex and hard to track function could eventually be written as a pipeline of smaller functions. But using only optionals to pipe functions together isn’t enough to take full advantage of this technique. With the help of a small, but useful Monad called Result (or Either) you can take your functional programming powers to the next level.

Transcript

1. Result Oriented Programming (in Swift) Saul Mora - saul@casademora.com - @casademora
2. …previously on…
3. Adventurez in Functional Swift Programming
4. func old_and_busted_expired(fileURL: NSURL) -> Bool { let fileManager = NSFileManager() if let filePath = fileURL.path { if fileManager.fileExistsAtPath(filePath) { var error: NSError? let fileAttributes = fileManager.attributesOfItemAtPath(filePath, error: &error) if let fileAttributes = fileAttributes { if let creationDate = fileAttributes[NSFileModificationDate] as? NSDate { return creationDate.isBefore(NSDate.oneDayAgo()) } } else { NSLog("No file attributes \(filePath)") } } } return true }
5. bind(A?, f(A)->B?) -> B?
6. >>-(A?, f(A)->B?) -> B?
7. func expired(fileURL: NSURL) -> Bool { return fileURL.path >>- fileExists >>- retrieveFileAttributes >>- extractCreationDate >>- checkExpired ?? true }
9. Result
10. …the Optional Type with more Power…
11. Error Handling
12. Optional
13. .none .some(value) Optional
14. .none(error) .some(value) Optional
15. .failure(error) .some(value) Optional
16. .failure(error) .success(value) Optional
17. .failure(error) .success(value) Result
18. enum Optional<T> { case none case some(_ value: T) }
19. enum Result<T> { case success(_ value: T) case failure(_ error: NSError) }
20. enum Result<T, E: Error> { case success(_ value: T) case failure(_ error: E) }
21. enum Result<T> { case success(_ value: T) case failure(_ error: NSError) }
22. func doSomethingFun() -> String? { return "跟朋友们⼀一起学习说中⽂文 !" }
23. func doSomethingFun() -> Optional<String> { return .some("跟朋友们⼀一起学习说中⽂文 !") }
24. func doSomethingFun() -> Result<String> { return .success("Ride bike across the Rocky Mountains "") }
25. let result = doSomethingFun() switch result { case .success(let funThing): print("Had fun: \(funThing)") case .error: print("Error having fun ") }
26. /// A type that can represent either a `Wrapped` value or `nil`, the absence /// of a value. public enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible { case None case Some(Wrapped) /// Construct a `nil` instance. public init() /// Construct a non-`nil` instance that stores `some`. public init(_ some: Wrapped) /// If `self == nil`, returns `nil`. Otherwise, returns `f(self!)`. @warn_unused_result public func map<U>(@noescape f: (Wrapped) throws -> U) rethrows -> U? /// Returns `nil` if `self` is `nil`, `f(self!)` otherwise. @warn_unused_result public func flatMap<U>(@noescape f: (Wrapped) throws -> U?) rethrows -> U? /// Create an instance initialized with `nil`. public init(nilLiteral: ()) }
27. map vs flatMap
28. Functors and Monads
29. Functor
30. wraps a Type, T
31. FunctorOf<T>
32. map
33. func map<U>(T-> U) -> FunctorOf<U>
34. Monad
35. wraps a Type, T
36. MonadOf<T>
37. flatMap
38. func flatMap<U>(T -> MondadOf<U>) -> MonadOf<U>
39. let string: String? = "string value"
40. let string: String? = "string value" let string = Optional<String>("string value")
41. string.map { print($0) }
42. string >>- { print($0) }
43. func map<U>(_ transform: T -> U) -> U? { switch self { case .some(let x): return .some(transform(x)) case .none: return .none } }
44. func map<U>(_ transform: T -> Result<U>) -> Result<U> { switch self { case .success(let value): return transform(value) case .failure(let error): return Result<T>.failure(error) } }
45. enum Result<T> { case success(_ value: T) case failure(_ error: Error) func map<U>(_ transform: T -> U) -> U { switch self { case .success(let value): return transform(value) case .failure(let error): return Result<T>.failure(error) } } }
46. let result: Result<String> = doSomething() result .map { value in print("Had fun: \(value)") }
47. let result: Result<String> = doSomething() result .map { value in print("Had fun: \(value)") } .mapError { error -> NSError in print("Error having fun: \(error)") } let result: Result<String> = doSomething() result .map { value in print("Had fun: \(value)") }
48. Micro-Networking Framework
49. request a data object asynchronously
50. func apiRequest<A> ( modifyRequest: NSMutableURLRequest -> (), baseURL: NSURL, resource: Resource<A>, failure: (Reason, NSData?) -> (), completion: A -> () )
51. func request<R: HTTPResource> ( resource: R, cachePolicy: URLRequest.CachePolicy, requestTimeout: TimeInterval, host: HTTPHost?, completion: (Result<R.RequestedType>) -> Void )
52. public protocol HTTPResourceProtocol { }
53. public protocol HTTPResourceProtocol { associatedtype ResultType associatedtype ErrorType: HTTPResourceError }
54. public protocol HTTPResourceProtocol { associatedtype ResultType associatedtype ErrorType: HTTPResourceError var path: String { get } var method: HTTPMethod { get } var queryParameters: [String: String] { get } var parse: Result<ResourceDataType, HTTPResponseError> { get } }
55. public typealias ResourceParseFunction<ResourceDataType> = (Data) -> Result<ResourceDataType, HTTPResponseError> public protocol HTTPResourceProtocol { associatedtype ResultType associatedtype ErrorType: HTTPResourceError var path: String { get } var method: HTTPMethod { get } var queryParameters: [String: String] { get } var parse: ResourceParseFunction<ResultType> { get } }
56. • validate response code • validate/preprocess data • deserialize JSON from data • decode JSON objects • call completion handler
57. func completionHandlerForRequest<R: HTTPResource>( resource: R, validate: ResponseValidationFunction, completion: @escaping (Result<R.RequestedType>) -> Void ) -> (Data?, URLResponse?, Error?) -> Void { return { (data, response, error) in _ = Result(response as? HTTPURLResponse, failWith: .InvalidResponseType) >>- validateResponse(error) >>- validate(data) >>- resource.parse >>- completion } } return { (data, response, error) in _ = Result(response as? HTTPURLResponse, failWith: .InvalidResponseType) >>- validateResponse(error) >>- validate(data) >>- resource.parse >>- completion }
58. return { (data, response, error) in _ = Result(response as? HTTPURLResponse, failWith: .InvalidResponseType) >>- validateResponse(error) >>- validate(data) >>- resource.parse >>- completion }
59. return { (data, response, error) in _ = Result(response as? HTTPURLResponse, failWith: .InvalidResponseType) >>- validateResponse(error) >>- validate(data) >>- resource.parse >>- completion }
60. func validateResponse(_ error: Error?) -> (HTTPURLResponse?) -> Result<HTTPURLResponse, HTTPResponseError>
61. _ = Result(response as? HTTPURLResponse, failWith: .InvalidResponseType) >>- validateResponse(error) >>- validate(data) >>- resource.parse >>- completion
62. func validate(Data?) -> (HTTPURLResponse) -> Result<Data>
63. _ = Result(response as? HTTPURLResponse, failWith: .InvalidResponseType) >>- validateResponse(error) >>- validate(data) >>- resource.parse >>- completion
64. response.parse: (Data) -> Result<ResourceType>
65. validateResponse : (HTTPURLResponse?) -> Result<HTTPURLResponse> customValidate : (HTTPURLResponse) -> Result<Data> response.parse : (Data) -> Result<ResourceType> completion : (Result<ResourceType>) -> Void
66. return { (data, response, error) in _ = Result(response as? HTTPURLResponse, failWith: .InvalidResponseType) >>- validateResponse(error) >>- validate(data) >>- resource.parse >>- completion }
67. func siteGauge(siteID: SiteID) -> HTTPResource<Gauge> { let path = "gauges/\(siteID)" return HTTPResource(path: path, parse: parse(rootKey: "gauge")) }
68. request(resource: siteGauge(siteID: "my_site_id")) { $0.map { site in print("Found \(site)") } }
69. request(resource: siteGauge(siteID: "my_site_id")) { result in result.map { site in print("Found \(site)") } .mapError { error -> HTTPResourceError in print("Error requesting resource: \(error)") return error } }
70. request(resource: siteGauge(siteID: "my_site_id")) { result in switch result { case .success(let site): print("Found \(site)”) case .failure(let error): print("Error getting site: \(error)") } }
71. Do I have to reimplement Result t0 get 4ll th3s Aw3somene55 1nto my co9eZ?
72. https://github.com/antitypical/Result Libraries https://github.com/casademora/CoreHTTP
73. Result Oriented Programming Saul Mora - saul@casademora.com - @casademora