Programação Funcional

Transcrição

1 Programação Funcional com Haskell Fabrício Olivetti de França Universidade Federal do ABC

2 Paradigma Funcional

3 Paradigmas Em muitos cursos de Computação e Engenharia iniciam com paradigma imperativo. Exemplo clássico da receita de bolo. 1

4 Paradigma Imperativo int pares[10]; for (int i=0; i<10; i++) { pares[i] = 2*i; } 2

5 Paradigma Imperativo Descrevo passo a passo o que deve ser feito. Infame goto. Evoluiu para o procedural e estruturado com if, while, for. 3

6 Paradigma Imperativo int pares[10]; for (int i=0; i<10; i++) { pares[i] = dobro(); } int dobro () { static int i = 0; ++i; return i; } 4

7 Problemas Ao seguir o passo a passo, você chega no resultado...mas não tem ideia de qual será ele. Qualquer um pode usar suas variáveis globais e suas funções, para o seu uso intencional ou não... 5

8 Orientação a Objetos Outro paradigma muito estudado em cursos de Computação. Encapsula dados com seus próprios métodos. Evita que certas informações e procedimentos sejam utilizados fora de seu contexto. 6

9 Orientação a Objetos class Pares { private int i; // n~ao quero ninguém mudando meu estado private ArrayList lista; public Pares() { i=0; lista = new ArrayList(); } public void addone() { ++i; lista.add(2*i); } public ArrayList get(){ return lista; } } 7

10 Orientação a Objetos class Main { public static void main(string[] args) { Pares l1 = new Pares(); l1.addone(); l1.addone(); l1.addone(); System.out.println(l1.get()); } } 8

11 Problemas 9

12 Problemas Nos textos didáticos temos exemplos simples e criados para ilustrar quando faz sentido termos objetos. Nem sempre isso representa a realidade. Composição de funções através de herança = bagunça! 10

13 Problemas Encapsula códigos imperativos para segurança e reuso, mas não evita os bugs na criação das classes. Usa estado intensivamente, incentiva mutabilidade e não-determinismo. Difícil de paralelizar. 11

14 Efeito colateral A execução da instrução atual depende do estado atual do sistema. Ex.: dobro() e addone() vai depender do estado atual de i. 12

15 Efeito colateral Eu posso executar a função dobro() para o primeiro e o segundo elemento em paralelo?? 13

16 Paradigma Funcional Computação = avaliação de composição de funções. Evita estados. Declarativo. 14

17 Paradigma Funcional take 10 [2*i i <- zplus] -- pegue 10 elementos da lista formada pelo -- dobro dos números inteiros positivos. 15

18 Paradigma Funcional Note que i não é uma variável, não muda de valor, é apenas um símbolo da definição. 16

19 Funções Puras Linguagens funcionais incentivam (ou obrigam) a criação de funções puras. Ao chamar a função com o mesmo argumento, sempre terá a mesma resposta. Se não temos efeito colateral......e o resultado de uma expressão pura não for utilizado, não precisa ser computado....o programa como um todo pode ser reorganizado e otimizado....é possível computar expressões em qualquer ordem (ou em paralelo). 17

20 Funções Puras double media (int * valores, int n) { double soma = 0; int i; for (i = 0; i < n; i++) soma_valor(&soma, valores[i]); return soma / n; } void soma_valor (double * soma, int valor) { soma += valor; } 18

21 Programação sem bugs A ausência de estados permite evitar muitos erros de implementação. O lema da linguagem Haskell: se compilou, o código está correto! 19

22 Iterações vs Recursões Em linguagens funcionais os laços iterativos são implementados via recursão, geralmente levando a um código enxuto e declarativo. 20

23 Iterações vs Recursões int gcd (int m, int n) { int r = m % n; while(r!= 0) { m = n; n = r; r = m%n; } return m; } 21

24 Iterações vs Recursões mdc 0 b = b mdc a 0 = a mdc a b = mdc b (a rem b) 22

25 Avaliação Preguiçosa Algumas linguagens funcionais implementam o conceito de avaliação preguiçosa. Quando uma expressão é gerada, ela gera uma promessa de execução. Se e quando necessário, ela é avaliada. 23

26 Avaliação Preguiçosa int main () { int x = 2; f(x*x, 4*x + 3); return 0; } int f(int x, int y) { return 2*x; } 24

27 Avaliação Preguiçosa int main () { int x = 2; f(2*2, 4*2 + 3); return 0; } int f(int x, int y) { return 2*x; } 25

28 Avaliação Preguiçosa int main () { int x = 2; f(4, 4*x + 3); return 0; } int f(int x, int y) { return 2*x; } 26

29 Avaliação Preguiçosa int main () { int x = 2; f(4, 11); return 0; } int f(int x, int y) { return 2*x; } 27

30 Avaliação Preguiçosa int main () { int x = 2; 8; return 0; } int f(int x, int y) { return 2*x; } 28

31 Avaliação Preguiçosa f x y = 2*x main = do let z = 2 print (f (z*z) (4*z + 3)) 29

32 Avaliação Preguiçosa f x y = 2*x main = do let z = 2 print (2 * (z*z)) 30

33 Avaliação Preguiçosa f x y = 2*x main = do let z = 2 print (8) A expressão 4 z + 3 nunca foi avaliada! 31

34 Avaliação Preguiçosa Isso permite a criação de listas infinitas: [2*i i <-[1..]] 32

35 Haskell

36 Haskell: ghc e ghci Glasgow Haskell Compiler: compilador de código aberto para a linguagem Haskell. Possui um modo interativo ghci (similar ao ipython). 33

37 Glasgow Haskell Compiler Uso recomendado de: Git - controle de revisão Cabal - gerenciamento de projeto e dependências Haddock - documentação $ mkdir hello $ cd hello $ mkdir bin $ vim Hello.hs 34

38 Primeiro projeto Hello.hs: Copyright (c) 2017 Nome - site -- GPL version 3 or later -- (see Módulo principal module Main where -- Funç~ao principal main :: IO () main = do print ("Hello World") 35

39 Primeiro projeto Indica que esse é o módulo principal que irá gerar o executável. module Main where 36

40 Primeiro projeto Função principal é uma função que não recebe parâmetros e retorna uma entrada e/ou saída de arquivos. main :: IO () 37

41 Primeiro projeto Início do programa: main = do 38

42 Primeiro projeto Instrução de entrada/saída de arquivos (para stdout): print ("Hello World") 39

43 Primeiro projeto $ git init $ git add Hello.hs $ git commit -am "olá mundo funcional!" 40

44 Primeiro projeto $ ghc -o bin/hello Hello.hs $./bin/hello 41

45 Primeiro projeto Para saber mais Criando um projeto usando Cabal (projetos grandes, não didáticos): to write a Haskell program 42

46 Para a disciplina Criem um repositório no github com o nome BIGDATA2018, coloquem todos seus códigos lá! Os códigos dados em aula estarão em: 43

47 Tipos Básicos

48 Tipos de Dados Haskell tem a tipagem forte e estática. Você não pode misturar tipos e esses devem ser bem definidos: let x = 1 :: Integer x + "texto" -- erro! N~ao pode somar um número a um texto x * erro! O valor inteiro n~ao se transforma em real x * 2 -- ok! 44

49 Tipos numéricos Int: inteiros de 32 ou 64 bits Integer: Inteiros de precisão arbitrária Float: ponto-flutuante precisão simples Double: ponto-flutuante precisão dupla 45

50 Operadores soma x y = x + y subtrai x y = x - y multiplica x y = x * y divide x y = x / y Prelude> :t (+) (+) :: Num a => a -> a -> a 46

51 Operadores soma x y = x + y subtrai x y = x - y multiplica x y = x * y divide x y = x / y Prelude> :t (/) (/) :: Fractional a => a -> a -> a 47

52 Operadores div/mod - arredonda na direção de quot/rem - arredonda na direção de 0 divideint1 x y = x div y divideint1 x y = x quot y resto1 x y = x mod y resto2 x y = x rem y 48

53 Operadores elevado1 x y elevado2 x y = x ^ y = x ** y (^) :: (Num a, Integral b) => a -> b -> a (**) :: Floating a => a -> a -> a 49

54 Classes de tipos Integral: todos os tipos inteiros Floating: todos os tipos reais Num: todos os números 50

55 Exemplo: razão áurea O ghc infere o tipo de acordo com suas operações. aurea = (1 + sqrt 5) / 2 51

56 Exercício Qual o tipo dessa expressão? aurea = (1 + sqrt 5) / 2 52

57 Exercício Qual o tipo dessa expressão? aurea :: Floating a => a aurea = (1 + sqrt 5) / 2 (poderia ser Double, né?) 53

58 Bool data Bool = True False 54

59 Bool igual x y = x == y diferente x y = x /= y maior x y = x > y menor x y = x < y maiorigual x y = x >= y menorigual x y = x <= y 55

60 Bool True && True == True True && False == False True False == True False False == False not True == False 56

61 Ano bissexto bissexto ano = (ano rem 400 == 0) ((ano rem 4 == 0) && (ano rem 100 /= 0)) Na prática podemos deixar o código mais enxuto... 57

62 Tuplas let x = (1, "palavra") Prelude> fst x 1 Prelude> snd x "palavra" 58

63 Funções

64 Funções O Haskell é baseado no Lambda Calculus em que a computação é baseada em funções de uma variável. Toda função recebe uma entrada e retorna uma saída! somaum :: Integer -> Integer somaum x = x

65 Funções de Uma Variável somaum Nome da função deve começar com caixa baixa. O estilo padrão é o camelcase. 60

66 Funções de Uma Variável somaum :: Definição dos tipos de entrada e saída. 61

67 Funções de Uma Variável somaum :: Integer Recebe um valor inteiro. 62

68 Funções de Uma Variável somaum :: Integer -> Integer Retorna um valor inteiro. 63

69 Funções de Uma Variável somaum :: Integer -> Integer somaum x A função, dado um valor x... 64

70 Funções de Uma Variável somaum :: Integer -> Integer somaum x =...é definida como... 65

71 Funções de Uma Variável somaum :: Integer -> Integer somaum x = x a expressão x

72 Mais de uma variável Funções de mais de uma variável, na verdade são composições de funções: soma x y = x + y Na verdade é: soma x y = (soma x) (y) -- resultado de soma x aplicado em y soma x y = \z -> x + z (y) 67

73 Mais de uma variável soma :: Integer -> (Integer -> Integer) soma é uma função que recebe um inteiro e retorna uma função que recebe um inteiro e retorna um inteiro. Para facilitar removemos os parênteses e fazemos a leitura como funções de múltiplas variáveis. 68

74 Constantes Quando fazemos: pi = 3.14 Não estamos declarando uma constante, mas sim uma função que não recebe parâmetros e retorna sempre o valor

75 Constantes Quando fazemos: pi :: Double pi = 3.14 Não estamos declarando uma constante, mas sim uma função que não recebe parâmetros e retorna sempre o valor

76 Assinatura soma :: Integer -> Integer -> Integer Essa é a assinatura da função, ela costuma dizer muito sobre o que ela faz. 71

77 Assinatura de classes Quando queremos criar uma função que recebe classes de tipos (ex.: Num) fazemos: soma :: Num a => a -> a -> a Se x e y forem inteiros, a função retornará um inteiro; se forem Double, ela retornará Double; se forem diferentes entre si, retornará um erro! 72

78 Assinatura genéricas Podemos também criar funções que recebem qualquer tipo: f :: a -> a -> b Função que recebe duas variáveis de um mesmo tipo qualquer e retorna uma variável de outro tipo. Aqui a, b são apenas nomes genéricos, pode ser qualquer outra letra. 73

79 Exercício Qual a única função possível com a seguinte assinatura? f :: a -> a 74

80 Exercício Qual a única função possível com a seguinte assinatura? f :: a -> a f x = x 75

81 Exercício Crie uma função que receba 3 valores do tipo Double: a, b, c e retorne as raízes da equação: a x 2 + b x + c. 76

82 Exercício Qual a assinatura dela? 77

83 Exercício raizseggrau :: Double -> Double -> Double -> (Double, Double) 78

84 Exercício Escreva a função! 79

85 Exercício raizseggrau :: Double -> Double -> Double -> (Double, Double) raizseggrau a b c = ((-b - (sqrt (b**2-4*a*c)))/(2*a), (-b + (sqrt (b**2-4*a*c)))/(2*a)) 80

86 Beleza prometida Podemos segmentar as definições de expressões através da instrução where. f x = expr where expr = expr1 + expr2 81

87 Beleza prometida O Haskell (assim como o Python) usa espaços para definir blocos. Lembre-se de manter seu código alinhado! f x = expr where expr = expr1 + expr2 82

88 Beleza prometida Muito melhor! raizseggrau :: Double -> Double -> Double -> (Double, Double) raizseggrau a b c = (x1, x2) where x1 = (-b - sqrt delta) / (2*a) x2 = (-b + sqrt delta) / (2*a) delta = b**2-4*a*c 83

89 Beleza prometida Mas e se delta for negativo??? raizseggrau :: Double -> Double -> Double -> (Double, Double) raizseggrau a b c = (x1, x2) where x1 = (-b - sqrt delta) / (2*a) x2 = (-b + sqrt delta) / (2*a) delta = b**2-4*a*c 84

90 Guard!! Os guards ( ) criam um desvio condicional para tratar certas possibilidades da sua função: f x cond1 = expr1 cond2 = expr2 otherwise = expr3 where expr1 =... expr2 =... expr3 =... Leia: a função f recebe um parâmetro x e, se a condição cond1 for verdadeira, retorne expr 1, se cond2 for verdadeira, retorne expr 2, caso contrário, retorne expr 3. Equivalente a um switch..case. 85

91 Guard!! raizseggrau :: Double -> Double -> Double -> (Double, Double) raizseggrau a b c delta < 0 = error "Raízes negativas!" otherwise = (x1, x2) where x1 = (-b - sqrt delta) / (2*a) x2 = (-b + sqrt delta) / (2*a) delta = b**2-4*a*c 86

92 Exercício Reescreva a seguinte função utilizando os conceitos aprendidos até então: bissexto ano = (ano rem 400 == 0) ((ano rem 4 == 0) && (ano rem 100 /= 0)) 87

93 Exercício bissexto ano ano divide 400 = True ano divide 4 = not $ ano divide 100 where divide x y = x rem y == 0 88

94 Pattern Matching É possível também prever alguns casos triviais de entrada. Considere a função: mult :: Num a => a -> a -> a mult x y = x * y 89

95 Pattern Matching Sabemos que x*1 = x 1*y = y 0*x = x*0 = 0 90

96 Pattern Matching mult :: (Eq a, Num a) => a -> a -> a mult 1 y = y mult x 1 = x mult 0 _ = 0 mult _ 0 = 0 mult x y = x * y 91

97 Pattern Matching Classe Eq indica que são números que permitem comparação de igualdade. mult :: (Eq a, Num a) => a -> a -> a mult 1 y = y mult x 1 = x mult 0 _ = 0 mult _ 0 = 0 mult x y = x * y 92

98 Pattern Matching significa não me importo com esse valor mult :: (Eq a, Num a) => a -> a -> a mult 1 y = y mult x 1 = x mult 0 _ = 0 mult _ 0 = 0 mult x y = x * y Os padrões são avaliados de cima para baixo até que um caso verdadeiro seja encontrado. 93

99 Exercício Use Pattern Matching para definir a função soma: soma :: (Eq a, Num a) => a -> a-> a soma x y = x + y 94

100 Exercício Use Pattern Matching para definir a função soma: soma :: (Eq a, Num a) => a -> a-> a soma 0 y = y soma x 0 = x soma x y = x + y 95

101 Composição de funções Digamos que temos duas funções: Uma para calcular a nota numérica final Outra para transformar a nota em conceito 96

102 Composição de funções mediafinal :: Double -> Double -> Double mediafinal p1 p2 = 0.4*p *p2 conceito :: Double -> Char conceito media media < 5 = F media < 6 = D media < 7 = C media < 8 = B otherwise = A 97

103 Composição de funções Para compor as duas funções podemos definir: a$b indica que queremos aplicar a no resultado de b. geraconceito :: Double -> Double -> Char geraconceito p1 p2 = conceito $ mediafinal p1 p2 98

104 Composição de funções Funções de uma variável podem ser compostas com o operador. nota :: Double -> Double nota x = x*2 conceito :: Double -> Char conceito x x > 5 = A otherwise = F calcconceito = conceito. nota 99

105 Exercício Dada a função aocubo e a função sqrt, utilize composição de funções para calcular a expressão: aocubo :: Num a => a -> a aocubo x = x^3 f (x) = (x + y) 3 100

106 Exercício Dada a função aocubo e a função sqrt, utilize composição de funções para calcular a expressão: aocubo :: Num a => a -> a aocubo x = x^3 f (x, y) = (x + y) 3 f :: Floating a => a -> a -> a f x y = sqrt. aocubo $ x + y 101

107 Recursão A recursividade permite expressar ideias declarativas. Composta por um ou mais casos bases (para que ela termine) e a chamada recursiva. n! = n.(n 1)! 102

108 Recursão Caso base: 1! = 0! = 1 103

109 Recursão Para n = 3: 3! = 3. 2! = ! = = 6 104

110 Recursão fatorial :: Integer -> Integer fatorial 0 = 1 fatorial 1 = 1 fatorial n = n * fatorial (n-1) 105

111 Recursão fatorial :: Integer -> Integer fatorial 0 = 1 fatorial 1 = 1 fatorial n = n * fatorial (n-1) Casos bases primeiro!! 106

112 Estouro de pilha Em muitas linguagens, a chamada recursiva suspende a operação, armazena o estado atual em uma pilha e tenta computar a chamada recursiva. Isso pode levar ao estouro de pilha. 107

113 Estouro de pilha No haskell ele não armazena o estado atual na pilha, mas expande a expressão a ser calculada. Efetivamente ele faz: 5! = 5 * 4! = 5 * 4 * 3!

114 Estouro de pilha A pilha de expressão pode estourar! Recursão caudal também é útil no Haskell. 109

115 Estouro de pilha fatorial :: Integer -> Integer fatorial 0 = 1 fatorial 1 = 1 fatorial n = fatorial n 1 where fatorial 1 r = r fatorial n r = fatorial (n-1) (n*r) 110

116 Multiplicação Etíope A multiplicação Etíope de dois números m, n é dado pela seguinte regra: Se m for par, o resultado é a aplicação da multiplicação em m/2, n 2. Se m for ímpar, o resultado a aplicação da multiplicação em m/2, n 2 somados a n. Se m for igual a 1, retorne n. 111

117 Multiplicação Etíope Exemplo: m n r

118 Multiplicação Etíope Implemente o algoritmo recursivo da Multiplicação Etíope. Em seguida, faça a versão caudal. 113

119 Multiplicação Etíope etiope :: Integer -> Integer -> Integer etiope m n m==1 = n par m = etiope (m div 2) (n * 2) otherwise = n + (etiope (m div 2) (n * 2)) 114

120 Multiplicação Etíope etiope :: Integer -> Integer -> Integer etiope m n = etiope m n 0 where etiope m n r m==1 = n + r par m = etiope (m div 2) (n * 2) r otherwise = etiope (m div 2) (n * 2) (r+n) 115

121 Listas

122 Listas Definição recursiva: ou é uma lista vazia ou um elemento do tipo genérico a concatenado com uma lista de a. data [a] = [] a : [a] (:) - concatenação de elemento com lista 116

123 Criando listas lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] lista1 = [1..10] -- [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] lista2 = [0,2..10] -- [0, 2, 4, 6, 8, 10] lista3 = [0,2..] -- [0, 2, 4, 6, 8, 10,..] 117

124 Criando listas -- [2..20] lista = [ 2*x x <- [1..10] ] -- [0,2,4..] lista = [ 2*x x <- [0..] ] lista = [ expr x x <- lista ] 118

125 Criando listas -- [ (1*1), (1*2),..., (2*1), (2*2)... ] -- produto cartesiano lista = [ x*y x <- [1..10], y <- [1..10] ] lista = [ expr x y x <- lista1, y <- lista2 ] 119

126 Criando listas -- [5, 10, 15..] lista = [ x x <- [1..100], x mod 5 == 0] lista = [ expr x x <- lista, se expr x for verdadeiro ] 120

127 Criando listas -- [1,2..] lista = 1 : prox lista where prox (x:resto) = (x+1) : prox resto (x : resto) é um pattern match que captura o primeiro elemento da lista em x e o restante da lista em resto. 121

128 Criando listas -- [1,2..] lista = 1 : prox lista lista = 1 : prox [1] lista = 1 : prox (1:[]) lista = 1 : (1+1) : prox [(1+1)]

129 Criando listas Fibonacci: fib = 1 : 2 : prox fib where prox (x : t@(y:z)) = (x+y) : prox t O padrão (x : t@(y : )) captura: x é o primeiro elemento da lista. t é o restante da lista faz um pattern matching em t. y é o segundo elemento da lista. z é a lista sem os dois primeiros elementos. 123

130 Exercício No jogo FizzBuzz, todo múltiplo de 3 é substituído por Fizz, todo múltiplo de 5 é substituído por Buzz e todo múltiplo de 3 e 5 é substituído por FizzBuss. Crie uma lista com os elementos que não serão substituídos. 124

131 Exercício notfizzbuzz = [ x x <- [1..], x rem 5 /= 0, x rem 3 /= 0 ] 125

132 Operações com listas

133 Concatenação lista1 = [2,3,4] lista2 = [1,2,3] x = 1 lista3 = lista1 ++ lista2 -- [2,3,4,1,2,3] lista4 = x : lista1 -- [1,2,34] (:) : a -> [a] -> [a] (++) : [a] -> [a] -> [a] 126

134 Propriedades length :: [a] -> Int length [] = 0 length (x:xs) = 1 + (length xs) null :: [a] -> Bool null [] = True null _ = False 127

135 Sublistas lista = [1..10] take :: Int -> [a] -> [a] take 0 xs = [] take n [] = [] take n (x:xs) = x : (take (n-1) xs) take 2 lista -- [1,2] 128

136 Strings como Lista Uma String em Haskell pode ser representada como uma lista do tipo Char: type String = [Char] palavra = "Ola Mundo" primeiraletra :: String -> Char primeiraletra (w:ws) = w primeiraletra palavra -- O 129

137 Trabalhando com Listas Suponha as listas: listanum = [5, 3, 1, 2, 4] listastr = ["cachorro", "gato", "arara"] 130

138 Trabalhando com Listas Digamos que queremos triplicar os números da primeira lista e colocar uma exclamação no final de cada string. Poderíamos fazer: listanum = [5, 3, 1, 2, 4] listatriplo = [3*x x <- listanum] addexc (x:[]) = x : [! ] addexc (x:xs) = x : addexc xs listastr = ["cachorro", "gato", "arara"] listastre = [addexc s s <- listastr] 131

139 Trabalhando com Listas O padrão: [f x x <- lista] é recorrente em muitos algoritmos, podemos criar uma função genérica map que sabe aplicar uma função f em qualquer tipo x. 132

140 Trabalhando com Listas A função map recebe uma função que transforma um tipo a no tipo b, uma lista do tipo a e retorna uma lista do tipo b. Note que a e b podem ser iguais. map :: (a -> b) -> [a] -> [b] map f xs = [f x x <- xs] triplica x = 3*x listatriplo = map triplica listanum listastre = map addexc listastr 133

141 Trabalhando com Listas Digamos agora que queremos remover todos os valores ímpares de listatriplo: listatriplopar = [x x <- listatriplo, even x] E também todos menores ou iguais a 4: listatriplopar = [x x <- listatriplo, even x, x > 4] Esse também é um padrão recorrente que podemos deixar mais claro utilizando a função filter. 134

142 Trabalhando com Listas A função filter, recebe uma função que avalia um tipo a em um booleano, uma lista do tipo a e retorna uma lista do mesmo tipo, filtrada pelo predicado. filter :: (a -> Bool) -> [a] -> [a] filter f xs = [x x <- xs, f x] maiorquatro x = x > 4 listafinal = filter maiorquatro $ filter even $ map triplica listanum Com isso conseguimos representar as operações como um fluxo de dados, os elementos de listanum passa pela função triplica para depois passar pelo crivo de even e, finalmente, por maiorquatro. 135

143 Funções anônimas Quando as funções a serem passadas como parâmetro são pequenas, podemos utilizar as funções anônimas: map (\x -> 3*x) listanum filter \x -> x > 4) listatriplo A sintaxe \ representa o símbolo λ, então devemos ler como função λ que recebe um parâmetro x e retorna ( ) uma expressão em função de x. Note que as funções anônimas podem ter apenas uma única expressão simples. 136

144 Pointfree notation Adicionalmente, quando a função já está definida ou é um operador podemos utilizar o estilo pointfree: map (3*) listanum map (*3) listanum filter (>4) listatriplo 137

145 Exercício Dada a seguinte função: collatz :: Integer -> Integer collatz n even n = n div 2 otherwise = 3*n + 1 Gere uma lista com os elementos ímpares da aplicação dessa função nos números naturais. 138

146 Exercício Dada a seguinte função: collatz :: Integer -> Integer collatz n even n = n div 2 otherwise = 3*n + 1 lista = filter odd $ map collatz [1..] Gere uma lista com os elementos ímpares da aplicação dessa função nos números naturais. 139

147 Trabalhando com Listas Agora queremos somar os valores de listafinal, para isso podemos criar uma função: sum :: Num a => [a] -> a 140

148 Trabalhando com Listas Agora queremos somar os valores de qtdebrinquedos, para isso podemos criar uma função: sum :: Num a => [a] -> a sum [] = 0 sum (x:xs) = x + (sum xs) total = sum listafinal 141

149 Trabalhando com Listas A função sum pode ser generalizada para qualquer tipo de operação. Digamos que queremos calcular a produtória de uma lista. Como podemos alterar sum? sum :: Num a => [a] -> a sum [] = 0 sum (x:xs) = x + (sum xs) prod :: Num a => [a] -> a 142

150 Trabalhando com Listas A função sum pode ser generalizada para qualquer tipo de operação. Digamos que queremos calcular a produtória de uma lista. Como podemos alterar sum? sum :: Num a => [a] -> a sum [] = 0 sum (x:xs) = x + (sum xs) prod :: Num a => [a] -> a prod [] = 1 pro (x:xs) = x * (prod xs) Basicamente alteramos o valor neutro de 0 parar 1 e o operador aplicado no caso genérico. 143

151 Folding Esse tipo de operação é conhecido como fold ou reduce dependendo da linguagem funcional. Basicamente essa operação parte de um elemento neutro e aplica uma operação de redução sequencialmente entre o acumulador atual e o próximo elemento da lista: foldr :: (a -> b -> a) -> a -> [b] -> a foldr f z [] = z foldr f z (x:xs) = f x (foldr f z xs) Uma função que agrega o resultado de um tipo a com um tipo b, um elemento neutro a e uma lista de b, resultando em a. 144

152 Folding Alternativamente podemos definir uma versão caudal: foldl :: (a -> b -> a) -> a -> [b] -> a foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs 145

153 Folding Nossas funções soma e produtoria podem ser definidas como: sum = foldl (+) 0 produtoria = foldl (*) 1 146

154 Exercício Dada a definição do operador &&: (&&) False _ = False (&&) _ False = False (&&) = True Expanda as seguintes expressões: foldl (&&) False [False, False, False, False] foldr (&&) False [False, False, False, False] 147

155 Exercício foldl (&&) (False && False) [False, False, False] foldl (&&) ((False && False) && False) [False, False] foldl (&&) (((False && False) && False) && False) [False] foldl (&&) (((False && False) && False) && False) && False (((False && False) && False) && False) && False False 148

156 Exercício False && (foldr (&&) False [False, False, False]) False 149

157 Trabalhando com Listas Finalmente, temos as funções sort e nub que ordena uma lista e gera apenas os elementos únicos, respectivamente: sort :: Ord a => [a] -> [a] nub :: Eq a => [a] -> [a] 150

158 Algebraic Data Type

159 Algebraic Data Types Tipos compostos de dados primitivos. Permite expressividade. 151

160 Tipos de Dados Algébricos Tipo soma: data Bool = True False data: declara que é um novo tipo Bool: nome do tipo True False: poder assumir ou True ou False 152

161 Tipos de Dados Algébricos Tipo produto: data Ponto = Ponto Double Double data: declara que é um novo tipo Ponto: nome do tipo Ponto: construtor (ou envelope) Double Double: tipos que ele encapsula 153

162 Tipos de Dados Algébricos Para ser possível imprimir esse tipo: data Ponto = Ponto Double Double deriving (Show) deriving: derivado de outra classe Show: tipo imprimível Isso faz com que o Haskell crie automaticamente uma instância da função show para esse tipo de dado. 154

163 Convertendo entre tipos e String A função read lê uma String e converte para um tipo específico, a função show converte um tipo para uma String. x = read "2" :: Integer y = read "2.3" :: Double z = read "True" :: Bool sx = show x sy = show y sz = show z 155

164 Tipos de Classe - deriving Além do Show temos os seguintes tipos de classe que podem ser derivadas: Read: que podem ser lidas a partir de uma String Eq: que possuem relação de igualdade Ord: possuem relação de ordem Enum: que são enumeráveis Bounded: possuem um limite inferior e superior Caso o compilador não consiga criar as funções pertinentes automaticamente, será necessário implementá-las. 156

165 Tipos de Classe - deriving Outras duas funções importantes para conversão: fromintegral: converte de um inteiro para um tipo da classe Num, pertinente para a expressão a ser calculada fromenum: converte para a posição de um tipo enumerável. 157

166 Tipos de Dados Algébricos data Ponto = Ponto Double Double deriving (Show) main = do print (Ponto ) Ponto

167 Tipos de Dados Algébricos data Ponto = Ponto Double Double deriving (Show) dist :: Ponto -> Ponto -> Double dist (Ponto x1 y1) (Ponto x2 y2) = sqrt $ (x1-x2)^2 + (y1-y2)^2 159

168 Tipos de Dados Algébricos data Circ = Circ Ponto Double deriving (Show) Quero mais declarativo! 160

169 Tipos de Dados Algébricos type Centro = Ponto type Raio = Double data Circ = Circ Centro Raio deriving (Show) type é um apelido para um tipo! 161

170 Tipos de Dados Algébricos data Dias = Seg Ter Qua Qui Sex Sab Dom deriving (Show, Enum) Enum é enumerativo: succ Seg == Ter pred Ter == Seg 162

171 Tipos de Dados Algébricos data Dias = Seg Ter Qua Qui Sex Sab Dom deriving (Show, Enum, Eq) Eq é comparativo de igualdade: Seg == Ter -- False Seg == Seg -- True 163

172 Tipos de Dados Algébricos data Dias = Seg Ter Qua Qui Sex Sab Dom deriving (Show, Enum, Ord) Ord é relacional: Seg < Ter Ter > Seg -- True -- False 164

173 Tipos de Dados Algébricos data List a = Nil Cons a (List a) Uma lista de tipo a é definido ou como vazio (Nil) ou como a constante do tipo a e uma lista do tipo a. [1,2,3] = Cons 1 (Cons 2 (Cons 3 Nil)) 165

174 Tipos de Dados Algébricos data Maybe a = Nothing Just a 166

175 Tipos de Dados Algébricos safediv :: Double -> Double -> Maybe Double safediv x y y==0 = Nothing otherwise = Just (x / y) media l = case safediv (sum l) (fromintegral $ length l) of Nothing -> 1/0 -- infinity Just m -> m 167

176 Atividade 01 Faça os exercícios das páginas Exercícios Básicos, Exercícios sobre Funções e Exercícios sobre Listas da seguinte página: Curso de Haskell 168