Fun with Ruby: Uma Abordagem Funcional

Palestra apresentada na RubyConf Brasil 2015

Transcript

1. Fun with Ruby Uma Abordagem Funcional
2. ! ! ! ! ! ! ! ! ! ! ! ! Salviano Ludgério salviano.lfg@gmail.com! @salvianoo
3. Agenda • Programação Funcional • Conceitos funcionais presentes no Ruby • Características funcionais ausentes no Ruby • Exemplos
4. Disclaimer • Cálculo Lambda • Teoria das Categorias • Monads
5. Não sou expert
6. Programação Funcional
7. O que a Internet fala?
10. Functions as building blocks
11. Functions as data
12. Funções como principal mecanismo de abstração
13. Transformação de dados
14. Pipeline de funções que transformam dados
15. Funcional != OO
16. [1,2,3].map(n => n * 2)! ! map (n => n * 2), [1,2,3]
17. O Renascimento das Linguagens Funcionais
18. Raízes na academia
19. Pouca presença na indústria
24. e também no Browser… ClojureScript Scala.js Elm LiveScript PureScript
25. Por que tanto entusiasmo?
26. Estruturas de Dados Imutáveis Concorrência
27. Legal! E o Ruby??
28. λ Lambdas! λ
29. No Cálculo Lambda λx.x
30. Scheme (define f! (lambda (x) x))
31. JavaScript var f = function(x) {! return x;! };
32. Ruby f = lambda { |a| a }
33. Ruby f = proc { |a| a }
34. Ruby f = Proc.new { |a| a }
35. Ruby f = ->(a) { a }
36. Ruby f = ->(a) { a } stabby lambda Ruby 1.9+
37. Ruby f = lambda { |a| a }! f = proc { |a| a }! f = Proc.new { |a| a }! f = ->(a) { a }
38. Como chamar a função? funcao[:x]! funcao.(:x)! funcao.call :x! ! Tem mais formas?
39. Proc X Lambda
40. Ambos são objetos Proc > lambda { }! #<Proc:0x007f97b3181828@(irb):1 (lambda)>! ! > proc { }! #<Proc:0x007f97b31786d8@(irb):2>
41. Proc x Lambda • Lambdas verificam a aridade da função (número de argumentos) • Procs não fazem a verificação da aridade
42. Tratam o return de forma diferente def lambda_test! lam = lambda { return }! lam.call! puts "Hello world"! end! ! lambda_test #=> Hello world def proc_test! prc = proc { return }! prc.call! puts "Hello world"! end! ! proc_test #=>
43. Blocos
44. [1,2,3].each do |a|! puts a * 2! end! ! [1,2,3].each(lambda {|a|! puts a * 2! })
45. # Syntax Sugar! ! # Herança de Smalltalk! ! (1 to: 5) collect: [ :i | 2 * i ]
46. Blocos • São funções anônimas • Não são objetos • Fazem parte da sintaxe de um método • Só podem aparecer na lista de argumentos de um método
47. Passando funções
48. def exec_func(f)! f.call(2)! end! ! dobro = ->(a) { a * 2 }! ! exec_func(dobro) #=> 4
49. dobro = -> { |a| a * 2 }! ! [1,2,3].each(&dobro)
50. Passando Funções Ruby • Operador &: Transforma uma lambda/proc em um bloco ruby
51. Passando Funções Ruby • Métodos que recebem bloco, usar operador & para passar um lambda
52. • Maneira certa de usar e passar funções como valores em Ruby: com lambdas e .call() • Procs se assemelham a procedures, não funções Passando funções
53. Closures
54. “Um objeto é dado com função. Uma closure é uma função com dados.” ! John D. Cook
55. nome_aluno = 'Salviano'! ! boletim = ->(nota) {! !!"#{nome_aluno} tirou #{nota}"! }! ! boletim.call 7.5
56. Função! +! Ambiente nome_aluno = 'Salviano'! ! boletim = ->(nota) {! !!"#{nome_aluno} tirou #{nota}"! }
57. disciplina = "Matemática"! ! resultado = ->() {! nome_aluno = 'Salviano'! ! boletim = ->(nota) {! "#{nome_aluno} tirou #{nota} em #{disciplina}"! }! !! !!boletim.call(7.5)! }.call
58. Escopo Léxico
59. nome_aluno = 'Salviano'! ! def boletim(nota)! "#{nome_aluno} tirou #{nota}"! end! ! boletim(7.5)
60. nome_aluno = 'Salviano'! ! def boletim(nota)! "#{nome_aluno} tirou #{nota}"! end! ! boletim(7.5) NameError: Undefined local variable or method nome_aluno
61. ( sobre métodos
62. Métodos não possuem escopo léxico
63. Logo, métodos não são closures
64. Não podem ser passados diretamente para outras funções.
65. Mas podem ser convertidos para objetos do tipo Method
66. ) voltando com closures
67. class Pessoa! attr_accessor :name! ! def initialize(name)! @name = name! end! end
68. Usar somente funções
69. Pessoa = ->(name) {! setname = ->(new_name) { name = new_name }! ! ->(attr) {! return name if attr == :getname! return setname if attr == :setname! }! }
70. Pessoa = ->(name) {! setname = ->(new_name) { name = new_name }! ! ->(attr) {! return name if attr == :getname! return setname if attr == :setname! }! }
71. Pessoa = ->(name) {! setname = ->(new_name) { name = new_name }! ! ->(attr) {! return name if attr == :getname! return setname if attr == :setname! }! }
72. Pessoa = ->(name) {! setname = ->(new_name) { name = new_name }! ! ->(attr) {! return name if attr == :getname! return setname if attr == :setname! }! }
73. pessoa = Pessoa.('John')! ! pessoa.(:getname) #=> John! pessoa.(:setname).('Joao') #=> Joao
74. + exemplo de closures
75. Stack = ->() {! _data = []! ! push = ->(thing) {! _data << thing! }! ! ->(attr) {! return push if attr == :push! return _data if attr == :data! }! }.call!
76. Stack = ->() {! _data = []! ! push = ->(thing) {! _data << thing! }! ! ->(attr) {! return push if attr == :push! return _data if attr == :data! }! }.call!
77. Stack = ->() {! _data = []! ! push = ->(thing) {! _data << thing! }! ! ->(attr) {! return push if attr == :push! return _data if attr == :data! }! }.call!
78. Stack = ->() {! _data = []! ! push = ->(thing) {! _data << thing! }! ! ->(attr) {! return push if attr == :push! return _data if attr == :data! }! }.call!
79. Stack = ->() {! _data = []! ! push = ->(thing) {! _data << thing! }! ! ->(attr) {! return push if attr == :push! return _data if attr == :data! }! }.call! Stack.(:push).(1)! Stack.(:push).(2)! Stack.(:push).(3)! ! Stack.(:data) #=> [1,2,3]
80. var Stack = () => {! var _data = []! ! return {! push: thing => _data.push(thing),! data: _data! }! }(); Stack.push(1)! Stack.push(2)! Stack.push(3)! ! Stack.data() //=> [1,2,3]! JS
81. Stack.push(1)! Stack.push(2)! Stack.push(3)! ! Stack.data() //=> [1,2,3]! JS var Stack = () => {! var _data = []! ! return {! push: thing => _data.push(thing),! data: _data! }! }();
82. • Escopo Léxico • Função + Ambiente, acesso as variáveis no momento de sua definição • Muito usado em JS para criar Factory Functions Closures
83. Função de Alta Ordem
84. Uma função que recebe outras funções como argumento ou retorna uma função como resultado.
85. Exemplo de Função de Alta Ordem
86. Pessoa = ->(name) {! setname = ->(new_name) { name = new_name }! ! ->(attr) {! return name if attr == :getname! return setname if attr == :setname! }! }
87. Currying
88. Processo de transformar uma função que recebe múltiplos argumentos em uma função que recebe apenas um argumento e retorna outra função se algum argumento ainda estiver faltando.
89. Currying soma = ->(a) {! ->(b) { a + b }! }! soma.(1).(2)
90. Proc#curry soma = ->(a, b) { a + b }! soma_com_curry = soma.curry! ! soma_com_curry.(1, 2)! soma_com_curry.(1).(2)
91. Composição de Funções
92. Composição de Função f o g
93. Composição de Função • Funções são encadeadas de modo que o output da primeira função é o input da segunda função. • Cria uma função que é o equivalente a f ( g ( x ) )
94. Composição de Função • pipeline operator do Elixir |> • pipe operator do Unix |
95. def compose(f, g)! ->(a) { f.(g.(a)) }! end
96. class Proc! def compose(g)! ->(*args) { self.(g.(*args)) }! end! ! alias * :compose! end
97. Composição de Função soma = ->(a, b) { a + b }! dobro = ->(a) { a * 2 }! ! soma_e_dobro = dobro * soma
98. ⚠️⚠️⚠️⚠️
99. F = ->() {! map = ->(func, list) { list.map(&func) }! filter = ->(func, list) { list.select(&func) }! ! ->(name) {! return map if name == :map! return filter if name == :filter! }! }.call
100. F.(:filter).call func, [1,2,3]
101. func = F.(:filter).call ->(a){ a }! ! func.call [1,2,3]
102. F = ->() {! map = ->(f, list) { list.map(&f) }.curry! filter = ->(f, list) { list.select(&f) }.curry! ! ->(name) {! return map if name == :map! return filter if name == :filter! }! }.call
103. Descrição do Problema • Selecionar a posição e título dos filmes da década de 90 com avaliação superior a 8.0
104. Movies = [! {! rank: 1,! title: 'The Shawshank Redemption',! year_release: 1994,! rating: 9.2! },! {! rank: 2,! title: 'The Godfather',! year_release: 1972,! rating: 9.2! },! ]
105. nineties = F.(:filter).call ->(movie) do! year_release = movie[:year_release]! year_release >= 1990 && year_release <= 1999! end
106. rating_8 = F.(:filter).call ->(movie) {! movie[:rating] > 8.0! }! ! titles = F.(:map).call ->(movie) {! "#{movie[:rank]} - #{movie[:title]}"! }
107. process_movies = titles * rating_8 * nineties! process_movies.call(Movies)! ! #=> ["1 - Movie1", "2 - Movie2"]
108. Composição de Funções • Muito usado em linguagens funcionais
109. Collection Pipeline
110. Collection Pipeline Movies! !.select { |m| m[:year_release] >= 1990 }! !.select { |m| m[:rating] > 8.0 }! !.map { |m| "#{m[:rank]} - #{m[:title]}" }
111. Recursão
112. Recursão • Comum em linguagens funcionais para processar listas, e resolução de problemas em geral. • Favorece a imutabilidade • Ruby não possui mecanismo de tail call optimization, o que inviabiliza
113. Recursão def somatorio(func, a, b)! return 0 if a > b! func.(a) + somatorio(func, a+1, b)! end! ! somatorio(double, 1, 5)
114. Lazy Evaluation
115. Enumerable#lazy (1..Float::INFINITY)! .map { |x| x * x }! .first(10)
116. Enumerable#lazy (1..Float::INFINITY)! .lazy! .map { |x| x * x }! .first(10)
117. Conclusões
118. Conclusões • Os conceitos são universais, sendo aproveitados em várias linguagens, como JavaScript • Aprender um novo paradigma de programação pode trazer mais aprendizados que aprender uma nova linguagem
119. Conclusões • Unhappy Lambda • Lack of tail call optimization • Lack of immutable data structures • Compor funções não é trivial
120. e agora?
121. SICP
122. Obrigado! Perguntas?