Em F# e ScalaTécnicas de Programação               Funcional        Vinícius Hana e Juliano Alves          @vinicius_hana ...
Apresentação
Primeiro de tudo: não são paradigmas             excludentes!
Programação funcional considera que   todas as operações são funções
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(...
Isso tem nome: funções de alta ordem
Perceberam que se parece com        matemática?
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...
Funções de alta ordem permitem   algumas coisas bem legais!
Funções de alta ordem    let funcao =         let lista = [0;1;2;3;4]         List.map (fun x -> x * 2) lista10
Agora, uma outra ideia:Dado f(x) = x + 1, se eu passar sempre         1, sempre vai dar 2?
Sim!E isso tem nome: transparência          referencial
Dada a mesma entrada, obteremos       sempre a mesma saídaOu seja, ausência de efeitos colaterais
Dá pra fazer isso em programação?    Sim, usando imutabilidade!
Mutabilidade    public int Resultado { get; set; }    public void Dobrar(int numero)    {         Resultado *= 2;    }15
Imutabilidade    DateTime.Now.AddDays(1);    // retorna novo datetime com a adição feita16
Dada a mesma entrada, obteremos     sempre a mesma saída
Ou seja, ausência de efeitos colaterais   – mais confiabilidade no código
F# e Scala suportam mutabilidade e            imutabilidade
Imutabilidade em Scala e F#    let x = 1 // imutavel    let mutable x = 1 // mutavel    val x = 1 // imutavel    var y = 1...
Isso ajuda demais em concorrência
Certo, mas como eu manipulo e alteroos itens de uma lista, então? Ela não é              imutável?
Simples: gere outra com nossa velha          amiga recursão!
Com recursão, podemos compor e        decompor listas
Recursão em listaslet rec reverse lista =      match lista with      | head :: tail -> (reverse tail) @ [head]      | [] -...
Percebeu uma estrutura diferente      para compor a lista?
Essa estrutura se chama pattern           matching
Ela lembra switch-case, porém com     muito mais funcionalidade
Pattern matching    match coisa with    | 1 | 3 -> …    | head :: tail -> …    | [] -> …    | _ -> …    lista match {     ...
E se eu iterar em uma listagigantesca, ou mesmo infinita?
Lista infinita? Isso não arrebentaria              a memória?
Não se você tiver lazy evaluation!
Lazy evaluation    let x = 10    let resultado = lazy (x + 10)    val x = { println("x"); 1 }    lazy val y = { println("y...
Vamos juntar tudo isso em uma implementação de Fibonacci?
Fibonacci    let rec fib n =         match n with         | x when n > 2 -> 1         | _ -> fib (n - 1) + fib (n - 2)    ...
Referências
Obrigado!Vinícius Hana e Juliano Alves  @vinicius_hana e @vonjuliano
www.lambda3.com.br
Upcoming SlideShare
Loading in...5
×

Técnicas de Programação Funcional

1,519

Published on

Slides da palestra do Lambda Day SP

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
1,519
On Slideshare
0
From Embeds
0
Number of Embeds
9
Actions
Shares
0
Downloads
0
Comments
0
Likes
0
Embeds 0
No embeds

No notes for 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

×