Técnicas de Programação Funcional

1.829 visualizações

Publicada em

Slides da palestra do Lambda Day SP

0 comentários
1 gostou
Estatísticas
Notas
  • Seja o primeiro a comentar

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

Nenhuma nota no slide

Técnicas de Programação Funcional

  1. 1. Em F# e ScalaTécnicas de Programação Funcional Vinícius Hana e Juliano Alves @vinicius_hana e @vonjuliano
  2. 2. Apresentação
  3. 3. Primeiro de tudo: não são paradigmas excludentes!
  4. 4. Programação funcional considera que todas as operações são funções
  5. 5. Todas as operações são funções def f(x: Int, g: (Int) => Int) = g(x) + 3 def g(x: Int) = x * 2 val resultado = f(4, g) // isso dá 115
  6. 6. Isso tem nome: funções de alta ordem
  7. 7. Perceberam que se parece com matemática?
  8. 8. Todas as operações são funções f(x) = x + 3 g(x) = x * 2 (f o g) = f(g(x)) = g(x) + 3 g(4) = 4 * 2 = 8  f(g(4)) = 8 +3 = 118
  9. 9. Funções de alta ordem permitem algumas coisas bem legais!
  10. 10. Funções de alta ordem let 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 sempre 1, sempre vai dar 2?
  12. 12. Sim!E isso tem nome: transparência referencial
  13. 13. Dada a mesma entrada, obteremos sempre a mesma saídaOu seja, ausência de efeitos colaterais
  14. 14. Dá pra fazer isso em programação? Sim, usando imutabilidade!
  15. 15. Mutabilidade public int Resultado { get; set; } public void Dobrar(int numero) { Resultado *= 2; }15
  16. 16. Imutabilidade DateTime.Now.AddDays(1); // retorna novo datetime com a adição feita16
  17. 17. Dada a mesma entrada, obteremos sempre 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 e imutabilidade
  20. 20. Imutabilidade em Scala e F# let x = 1 // imutavel let mutable x = 1 // mutavel val x = 1 // imutavel var 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 velha amiga recursão!
  24. 24. Com recursão, podemos compor e decompor 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 diferente para compor a lista?
  27. 27. Essa estrutura se chama pattern matching
  28. 28. Ela lembra switch-case, porém com muito mais funcionalidade
  29. 29. Pattern matching match 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 arrebentaria a memória?
  32. 32. Não se você tiver lazy evaluation!
  33. 33. Lazy evaluation let x = 10 let resultado = lazy (x + 10) val x = { println("x"); 1 } lazy val y = { println("y"); 2 }33
  34. 34. Vamos juntar tudo isso em uma implementação de Fibonacci?
  35. 35. Fibonacci let rec fib n = match n with | x when n > 2 -> 1 | _ -> fib (n - 1) + fib (n - 2) val seq: Stream[BigInt] = 0 #:: 1 #:: (seq zip seq.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

×