Técnicas de programação funcional

394 visualizações

Publicada em

Publicada em: Tecnologia
0 comentários
0 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

Sem downloads
Visualizações
Visualizações totais
394
No SlideShare
0
A partir de incorporações
0
Número de incorporações
1
Ações
Compartilhamentos
0
Downloads
12
Comentários
0
Gostaram
0
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Técnicas de programação funcional

  1. 1. Técnicas de ProgramaçãoFuncionalEm F# e ScalaVinícius Hana e Juliano Alves@vinicius_hana e @vonjuliano
  2. 2. Apresentação
  3. 3. Primeiro de tudo: não são paradigmasexcludentes!
  4. 4. Programação funcional considera quetodas as operações são funções
  5. 5. Todas as operações são funçõesdef f(x: Int, g: (Int) => Int) = g(x) + 3def g(x: Int) = x * 2val resultado = f(4, g) // isso dá 115
  6. 6. Isso tem nome: funções de alta ordem
  7. 7. Perceberam que se parece commatemática?
  8. 8. Todas as operações são funçõesf(x) = x + 3g(x) = x * 2(f o g) = f(g(x)) = g(x) + 3g(4) = 4 * 2 = 8  f(g(4)) = 8 +3 = 118
  9. 9. Funções de alta ordem permitemalgumas coisas bem legais!
  10. 10. Funções de alta ordemlet funcao =let lista = [0;1;2;3;4]List.map (fun x -> x * 2) lista10
  11. 11. Agora, uma outra ideia:Dado f(x) = x + 1, se eu passar sempre1, sempre vai dar 2?
  12. 12. Sim!E isso tem nome: transparênciareferencial
  13. 13. Dada a mesma entrada, obteremossempre a mesma saídaOu seja, ausência de efeitos colaterais
  14. 14. Dá pra fazer isso em programação?Sim, usando imutabilidade!
  15. 15. Mutabilidadepublic int Resultado { get; set; }public void Dobrar(int numero){Resultado *= 2;}15
  16. 16. ImutabilidadeDateTime.Now.AddDays(1);// retorna novo datetime com a adição feita16
  17. 17. Dada a mesma entrada, obteremossempre a mesma saída
  18. 18. Ou seja, ausência de efeitos colaterais– mais confiabilidade no código
  19. 19. F# e Scala suportam mutabilidade eimutabilidade
  20. 20. Imutabilidade em Scala e F#let x = 1 // imutavellet mutable x = 1 // mutavelval x = 1 // imutavelvar y = 1 // mutavel20
  21. 21. Isso ajuda demais em concorrência
  22. 22. Certo, mas como eu manipulo e alteroos itens de uma lista, então? Ela não éimutável?
  23. 23. Simples: gere outra com nossa velhaamiga recursão!
  24. 24. Com recursão, podemos compor edecompor listas
  25. 25. Recursão em listaslet rec reverse lista =match lista with| head :: tail -> (reverse tail) @ [head]| [] -> []def reverse[T](list: List[T]): List[T] = list match {case head :: tail => reverse(tail) ++ List(head)case Nil => Nil}
  26. 26. Percebeu uma estrutura diferentepara compor a lista?
  27. 27. Essa estrutura se chama patternmatching
  28. 28. Ela lembra switch-case, porém commuito mais funcionalidade
  29. 29. Pattern matchingmatch coisa with| 1 | 3 -> …| head :: tail -> …| [] -> …| _ -> …lista match {case 1 => …case head :: tail => …case Nil => …case _ => …29
  30. 30. E se eu iterar em uma listagigantesca, ou mesmo infinita?
  31. 31. Lista infinita? Isso não arrebentariaa memória?
  32. 32. Não se você tiver lazy evaluation!
  33. 33. Lazy evaluationlet x = 10let resultado = lazy (x + 10)val x = { println("x"); 1 }lazy val y = { println("y"); 2 }33
  34. 34. Vamos juntar tudo isso em umaimplementação de Fibonacci?
  35. 35. Fibonaccilet rec fib n =match n with| x when n > 2 -> 1| _ -> fib (n - 1) + fib (n - 2)val seq: Stream[BigInt] = 0 #:: 1 #:: (seq zipseq.tail).map { case (a, b) => a + b }def elemento(posicao: Int): BigInt = seq(posicao- 1)35
  36. 36. Referências
  37. 37. Obrigado!Vinícius Hana e Juliano Alves@vinicius_hana e @vonjuliano
  38. 38. www.lambda3.com.br

×