Functional Programming in Swift

Talk about Functional Programming in Swift from NSConfArg 2015

Transcript

2. FUNCTIONAL PROGRAMMING SWIFT @_AdrianFerreyra Adrián Ferreyra
3. Bases de Functional Programming. Composición de funciones. Monoides. Monads. Funciones de orden superior. Functors. Usted está aquí.
4. FUNCTIONAL PROGRAMMING ?
5. PARADIGMA Marco teórico para el desarrollo de ideas
6. Modelo matemático Relación entre conjuntos con existencia y unicidad Función
7. Función Input Sin efectos colaterales Completamente aislada del entorno
8. Función Input Transparencia Referencial Output Garantiza el desacople del software de la implementación de la función.
9. Para qué sirve?
10. Describir qué hacer, no cómo hacerlo.
11. Completo control de la complejidad de la solución.
12. Diseño integro. Sin sorpresas.
13. Go Swifty.
14. Bases de Functional Programming. ✓ Composición de funciones. Monoides. Monads. Funciones de orden superior. Functors. Usted está aquí.
15. Funciones en Swift F: Int ➞ String func myFunction(param: Int) -> String { … return … }
16. Funciones en Swift F: (Int,Int) ➞ String func myFunction(p1: Int,p2: Int) -> String { … return … }
17. Funciones en Swift F: A ➞ B func myFunction <A,B>(param: A) -> B { … return … }
18. Composición de funciones. •Garantiza estabilidad completa de la composición. •Controla complejidad creciendo paulatinamente.
19. Operador Composición Swift nos permite definir operadores propios del mismo modo que definimos funciones
20. Operador Composición //Definición de operator infijo infix operator >>> { associativity left precedence 100 } //Definición de la función func >>> <A>(f: A->A, g: A->A) -> A -> A { return { x in g(f(x)) } }
21. Ejemplo
23. typealias Filter = CIImage -> CIImage
24. func blur10(image:CIImage) -> CIImage { let filter = CIFilter(name: "CIGaussianBlur", withInputParameters: [kCIInputRadiusKey: 10, kCIInputImageKey: image]); return filter.outputImage; }
26. func sepia(image:CIImage) -> CIImage { let filter = CIFilter(name: “CISepiaTone", withInputParameters: [kCIInputIntensityKey: 0.8, kCIInputImageKey: image]); return filter.outputImage; }
28. infix operator >>> {associativity left} func >>>(f1:Filter, f2:Filter) -> Filter { return {(x:CIImage) in f2(f1(x))} } let composedFilter = sepia >>> blur10
30. Monoid
31. Monoid Dado un espacio de funciones con el mismo tipo •Operación binaria asociativa cerrada Operador composición >>> func f <A>(param: A) -> A { … } func g <A>(param: A) -> A { … } •Elemento Identidad func id <A>(param: A) -> A { return param }
32. Bases de Functional Programming. ✓ Composición de funciones. ✓ Monoides. ✓ Monads. Funciones de orden superior. Functors. Usted está aquí.
33. Funciones de orden superior Toma funciones como parámetro o valor de retorno
34. Filter, Reduce y Map
35. Filter Filtra el array de acuerdo a la condición pasada por parámetro y retorna un array.
36. let payments = [40,20,50,30,15,25,60] var filteredArray : [Int] = [] for money in payments { if (money > 30) { filteredArray += [money] } }
37. let filteredArray = payments.filter({ (money:Int) in return money > 30 }) let payments = [40,20,50,30,15,25,60]
38. let filteredArray = payments.filter({ (money:Int) in money > 30 })
39. let filteredArray = payments.filter({ $0 > 30 })
40. let filteredArray = payments.filter { $0 > 30 } Swifty
41. Reduce
42. let payments = [40,20,50,30,15,25,60] var acumulator = 0 for money in payments { acumulator += money }
43. let acumulator = payments.reduce(0, combine: { $0 + $1 } ) let payments = [40,20,50,30,15,25,60]
44. Toma los elementos de un array, les aplica una transformación y devuelve un array con los resultados. Map
45. let payments = [40,20,50,30,15,25,60] var modifiedPayments: [Double] = [] for money in payments { modifiedPayments.append(Double(money) * 1.1) }
46. let payments = [40,20,50,30,15,25,60] let modifiedPayments = payments.map { Double($0) * 1.1 }
47. Map Toma un contenedor, les aplica una transformación y devuelve el contenedor con los resultados. Es posible definir Map para cualquier contenedor de datos
48. Functor Modela un contexto para un valor.
49. let array = [40,20,50,30,15,25,60] let tuple = ("Hello there!”,123) let optionalString = Optional("Hello there!") let dictionary = {"value":123} enum Result<A> { case Exists(A) case None }
50. Map Podemos definir nuestra propia versión, sobre nuestros functores. Definiciones en Swift
51. Bases de Functional Programming. ✓ Composición de funciones. ✓ Monoides. ✓ Monads. Funciones de orden superior. ✓ Functors. ✓ Usted está aquí.
52. Monads
53. Monad • Type Constructor • Bind Operation • Unit Operation 3 partes FP Concept
54. Type constructor Operación que nos permite construir tipos compuestos a partir de tipos más simples.
55. Monad • Bind Operation func flatMap <U>(f: A -> M<U>) -> M<U> { return self.flatten(self.map(f)) } FlatMap (Bind)
56. Monad func unit <U>(value: U) -> M<U> { return M(value); } • Unit Operation
57. Monad Desde Swift 1.2 (Xcode 6.3) FlatMap func flatMap<U>(transform: @noescape (T) -> [U]) -> [U] (8/ABR/2015)
58. func f <A>(a:A)->A {… return a} // A -> A func g <A>(a:A)->A {… return a} // A -> A >>> // (A -> A, A -> A) -> (A -> A) ✅
59. func f <A>(a:A)->M<A> { return M(a) } // A -> M<A> func g <A>(a:A)->M<A> { return M(a) } // A -> M<A> >>> // (A -> A, A -> A) -> (A -> A) ❌
60. func f <A>(a: A) -> M<A> { return M(a) } // A -> M<A> func g <A>(a: A) -> M<A> { return M(a) } // A -> M<A> var composition = {(a:Int) in f(a) >>= g} // \ A -> { (M<A>, transformación: A -> M<A>) -> M<A> } // \ A -> M<A> ✅
61. Async with Monads
62. class Future { … }
63. enum FutureResult<A> { case NotFinished case Finished(Optional<A>) }
64. class Future<A> { var result: FutureResult<A> init () { result = .NotFinished } init (_ x:A) { result = .Finished(x) } }
65. var callback: (A? -> Void)? = nil
66. func bind <B>(f:A? -> Future<B>) -> Future<B> { var returnFuture = Future<B>() self.callback = {(x:A?) in var secondFuture = f(x) secondFuture.callback = { (y:B?) -> Void in returnFuture.result = .Finished(y) } } return returnFuture }
67. infix operator >>>= {associativity left} func >>>= <A,B>(m:Future<A>,f:A? -> Future<B>) -> Future<B> { return m.bind(f) }
68. func getURL (s:String?) -> Future<NSURL> { var returnFuture = Future<NSURL>() if let unwrappedString = s { returnFuture.result = .Finished(NSURL(string: unwrappedString)) } else { returnFuture.result = .Finished(nil) } return returnFuture }
69. func httpGet (s:NSURL?) -> Future<NSData> { println("httpGet") var returnFuture = Future<NSData>() if let unwrappedURL = s { let task = NSURLSession.sharedSession().dataTaskWithURL(unwrappedURL) {(data, response, error) in if((error) != nil) { returnFuture.result = .Finished(nil) } else { returnFuture.result = .Finished(data) } } task.resume() } else { returnFuture.result = .Finished(nil) } return returnFuture }
70. func responseString (data:NSData?) -> Future<String> { println("responseString") var returnFuture = Future<String>() if let unwrappedData = data { returnFuture.result = .Finished(NSString(data: unwrappedData, encoding: NSUTF8StringEncoding) as? String) } else { returnFuture.result = .Finished(nil) } return returnFuture }
71. let getResponseString = { unit($0) >>>= getURL >>>= httpGet >>>= responseString } let response = getResponseString("http://nsconfarg.com") response.callback = {println("\($0)")}
72. github.com/AdrianFerreyra/ FunctionalSwiftNSConfArg2015
73. Recapitulando
74. Funcionalmente modular. Diseñamos pensando en funcionalidades, no de los componentes del sistema. Composition is the only way to control complexity.
75. Funciones y su composición. Funciones de orden superior. Map y Functors. Monoids. Monads.
76. ¿Preguntas?