Por que dizemos que Scala é uma linguagem funcional?

Presented at: VII Scaladores, June/2012.

Transcript

1. POR QUE DIZEMOS QUE SCALA É UMA LINGUAGEM FUNCIONAL?
2. Pedro Matiello pmatiello@gmail.com @pmatiello POR QUE DIZEMOS QUE SCALA É UMA LINGUAGEM FUNCIONAL?
3. SCALA
4. •Tipagem estática •Programação orientada a objetos •Programação funcional
5. PROGRAMAÇÃO FUNCIONAL
6. •Hughes, John.: Why Functional Programming Matters. The Computer Journal (1984)
7. •A operação fundamental é a aplicação de funções
8. •Um programa é uma função •Normalmente composta de outras funções •A entrada são os argumentos •A saída é o valor devolvido
9.             f(x) = x²
10. •Transparência referencial (referential transparency) •A aplicação de uma função não produz efeitos colaterais
11. •Funções de ordem superior (higher-order functions) •Avaliação atrasada (lazy evaluation)
12. FUNÇÕES DE ORDEM SUPERIOR
13. •Uma função de ordem superior satisfaz ao menos uma das propriedades abaixo: •Aceita ao menos uma função como argumento •Devolve uma função
14. scala> def square(i:Int) = i*i square: (i: Int)Int scala> val list = (1 to 10).toList list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
15. scala> def square(i:Int) = i*i square: (i: Int)Int scala> val list = (1 to 10).toList list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) scala> list.map(square) res0: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
16. scala> def square(i:Int) = i*i square: (i: Int)Int scala> val list = (1 to 10).toList list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) scala> list.map(square) res0: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
17. AVALIAÇÃO ATRASADA
18. •Estratégia de avaliação que satisfaz ambas as propriedades abaixo: •A avaliação da expressão é atrasada até que o valor seja necessário (non-strict evaluation) •Avaliações repetidas são evitadas (sharing)
19. def loop(condition: => Boolean)(expression: => Unit) { if (condition) { expression loop(condition)(expression) } } CALL BY NAME
20. def loop(condition: => Boolean)(expression: => Unit) { if (condition) { expression loop(condition)(expression) } } CALL BY NAME
21. def loop(condition: => Boolean)(expression: => Unit) { if (condition) { expression loop(condition)(expression) } } var i = 0; loop(i < 5) { println(i); i=i+1 } CALL BY NAME
22. def loop(condition: => Boolean)(expression: => Unit) { if (condition) { expression loop(condition)(expression) } } var i = 0; loop(i < 5) { println(i); i=i+1 } 0 1 2 3 4 CALL BY NAME
23. def loop(condition: => Boolean)(expression: => Unit) { if (condition) { expression loop(condition)(expression) } } var i = 0; loop(i < 5) { println(i); i=i+1 } 0 1 2 3 4 CALL BY NAME (apenas non-strict evaluation)
24. scala> lazy val x = { println("avaliou x"); "XXX" } x: java.lang.String = <lazy> scala> lazy val y = { println("avaliou y"); "YYY" } y: java.lang.String = <lazy> LAZY VALS
25. scala> lazy val x = { println("avaliou x"); "XXX" } x: java.lang.String = <lazy> scala> lazy val y = { println("avaliou y"); "YYY" } y: java.lang.String = <lazy> LAZY VALS
26. scala> lazy val x = { println("avaliou x"); "XXX" } x: java.lang.String = <lazy> scala> lazy val y = { println("avaliou y"); "YYY" } y: java.lang.String = <lazy> scala> if (true) x else y LAZY VALS
27. scala> lazy val x = { println("avaliou x"); "XXX" } x: java.lang.String = <lazy> scala> lazy val y = { println("avaliou y"); "YYY" } y: java.lang.String = <lazy> scala> if (true) x else y avaliou x res0: java.lang.String = XXX LAZY VALS
28. scala> lazy val x = { println("avaliou x"); "XXX" } x: java.lang.String = <lazy> scala> lazy val y = { println("avaliou y"); "YYY" } y: java.lang.String = <lazy> scala> if (true) x else y avaliou x res0: java.lang.String = XXX scala> if (true) x else y LAZY VALS
29. scala> lazy val x = { println("avaliou x"); "XXX" } x: java.lang.String = <lazy> scala> lazy val y = { println("avaliou y"); "YYY" } y: java.lang.String = <lazy> scala> if (true) x else y avaliou x res0: java.lang.String = XXX scala> if (true) x else y res1: java.lang.String = XXX LAZY VALS
30. scala> lazy val eagerNaturals:List[Int] = 0 :: eagerNaturals.map(_+1) eagerNaturals: List[Int] = <lazy> STREAMS
31. scala> lazy val eagerNaturals:List[Int] = 0 :: eagerNaturals.map(_+1) eagerNaturals: List[Int] = <lazy> scala> eagerNaturals.take(20) java.lang.StackOverflowError ! at .eagerNaturals(<console>:7) ! at .eagerNaturals(<console>:7) ! ... STREAMS
32. scala> lazy val lazyNaturals:Stream[Int] = 0 #:: lazyNaturals.map(_+1) lazyNaturals: Stream[Int] = <lazy> STREAMS
33. scala> lazy val lazyNaturals:Stream[Int] = 0 #:: lazyNaturals.map(_+1) lazyNaturals: Stream[Int] = <lazy> scala> lazyNaturals.take(20) res0: scala.collection.immutable.Stream[Int] = Stream(0, ?) STREAMS
34. scala> lazy val lazyNaturals:Stream[Int] = 0 #:: lazyNaturals.map(_+1) lazyNaturals: Stream[Int] = <lazy> scala> lazyNaturals.take(20).toList res1: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19) STREAMS
35. POR QUE DIZEMOS QUE SCALA É UMA LINGUAGEM FUNCIONAL? Pedro Matiello pmatiello@gmail.com @pmatiello