Técnicas de Programação Funcional
1 gostou1,969 visualizações
O documento apresenta técnicas de programação funcional em F# e Scala, como funções de alta ordem, imutabilidade, pattern matching e avaliação preguiçosa. Estas técnicas permitem maior confiabilidade no código e facilitam a manipulação de listas e estruturas de dados de forma funcional.
![Funções de alta ordem
let funcao =
let lista = [0;1;2;3;4]
List.map (fun x -> x * 2) lista
1
0](https://image.slidesharecdn.com/tcnicasdeprogramaofuncional-130418102123-phpapp02/85/Tecnicas-de-Programacao-Funcional-10-320.jpg)
![Recursão em listas
let 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
}](https://image.slidesharecdn.com/tcnicasdeprogramaofuncional-130418102123-phpapp02/85/Tecnicas-de-Programacao-Funcional-25-320.jpg)
![Pattern matching
match coisa with
| 1 | 3 -> …
| head :: tail -> …
| [] -> …
| _ -> …
lista match {
case 1 => …
case head :: tail => …
case Nil => …
case _ => …
2
9](https://image.slidesharecdn.com/tcnicasdeprogramaofuncional-130418102123-phpapp02/85/Tecnicas-de-Programacao-Funcional-29-320.jpg)
![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)
3
5](https://image.slidesharecdn.com/tcnicasdeprogramaofuncional-130418102123-phpapp02/85/Tecnicas-de-Programacao-Funcional-35-320.jpg)
Técnicas de Programação Funcional
- 1. Em F# e Scala Técnicas de Programação Funcional Vinícius Hana e Juliano Alves @vinicius_hana e @vonjuliano
- 2. Apresentação
- 3. Primeiro de tudo: não são paradigmas excludentes!
- 4. Programação funcional considera que todas as operações são funções
- 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á 11 5
- 6. Isso tem nome: funções de alta ordem
- 7. Perceberam que se parece com matemática?
- 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 = 11 8
- 9. Funções de alta ordem permitem algumas coisas bem legais!
- 10. Funções de alta ordem let funcao = let lista = [0;1;2;3;4] List.map (fun x -> x * 2) lista 1 0
- 11. Agora, uma outra ideia: Dado f(x) = x + 1, se eu passar sempre 1, sempre vai dar 2?
- 12. Sim! E isso tem nome: transparência referencial
- 13. Dada a mesma entrada, obteremos sempre a mesma saída Ou seja, ausência de efeitos colaterais
- 14. Dá pra fazer isso em programação? Sim, usando imutabilidade!
- 15. Mutabilidade public int Resultado { get; set; } public void Dobrar(int numero) { Resultado *= 2; } 1 5
- 16. Imutabilidade DateTime.Now.AddDays(1); // retorna novo datetime com a adição feita 1 6
- 17. Dada a mesma entrada, obteremos sempre a mesma saída
- 18. Ou seja, ausência de efeitos colaterais – mais confiabilidade no código
- 19. F# e Scala suportam mutabilidade e imutabilidade
- 20. Imutabilidade em Scala e F# let x = 1 // imutavel let mutable x = 1 // mutavel val x = 1 // imutavel var y = 1 // mutavel 2 0
- 21. Isso ajuda demais em concorrência
- 22. Certo, mas como eu manipulo e altero os itens de uma lista, então? Ela não é imutável?
- 23. Simples: gere outra com nossa velha amiga recursão!
- 24. Com recursão, podemos compor e decompor listas
- 25. Recursão em listas let 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. Percebeu uma estrutura diferente para compor a lista?
- 27. Essa estrutura se chama pattern matching
- 28. Ela lembra switch-case, porém com muito mais funcionalidade
- 29. Pattern matching match coisa with | 1 | 3 -> … | head :: tail -> … | [] -> … | _ -> … lista match { case 1 => … case head :: tail => … case Nil => … case _ => … 2 9
- 30. E se eu iterar em uma lista gigantesca, ou mesmo infinita?
- 31. Lista infinita? Isso não arrebentaria a memória?
- 32. Não se você tiver lazy evaluation!
- 33. Lazy evaluation let x = 10 let resultado = lazy (x + 10) val x = { println("x"); 1 } lazy val y = { println("y"); 2 } 3 3
- 34. Vamos juntar tudo isso em uma implementação de Fibonacci?
- 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) 3 5
- 36. Referências
- 37. Obrigado! Vinícius Hana e Juliano Alves @vinicius_hana e @vonjuliano