Programação Funcional. Aula 3. Tipos e Classes. José Romildo Malaquias. Departamento de Computação Universidade Federal de Ouro Preto 2011.

Transcrição

1 Programação Funcional Aula 3 Tipos e Classes José Romildo Malaquias Departamento de Computação Universidade Federal de Ouro Preto José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

2 O que é um tipo? Um tipo é um nome para uma coleção de valores relacionados. Por exemplo, em Haskell o tipo básico Bool contém os dois valores lógicos: False True José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

3 Erros de tipo A aplicação de uma função a um ou mais argumentos do tipo errado constitui um erro de tipo. Por exemplo: > 1 + False <interactive>:0:1: No instance for (Num Bool) arising from the literal 1 Possible fix: add an instance declaration for (Num Bool) In the first argument of (+), namely 1 In the expression: 1 + False In an equation for it : it = 1 + False 1 é um número e False é um valor lógico, mas + requer dois números. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

4 Tipos em Haskell Se a avaliação de uma expressão e produz um valor do tipo t, então o tipo de e é t, e escrevemos: e :: t Toda expressão bem formada tem um tipo, que pode ser calculado automaticamente em tempo de compilação usando um processo chamado inferência de tipos. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

5 Tipos em Haskell (cont.) Todos os erros de tipo são encontrados em tempo de compilação, o que torna os programas mais seguros e mais rápidos, eliminando a necessidade de verificações de tipo em tempo de execução. No GHCi, o comando :type calcula o tipo de uma expressão, sem avaliá-la: Prelude> not False True Prelude> :type not False not False :: Bool Prelude> José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

6 Tipos básicos Haskell tem um número de tipos básicos, incluindo: Bool Char String Int Integer Float Double Rational valores lógicos caracteres simples seqüências de caracteres inteiros de precisão fixa inteiros de precisão arbitrária núm. em ponto flutuante com precisão simples núm. em ponto flutuante com precisão dupla números racionais de precisão arbitrária José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

7 Tipos listas Uma lista é uma seqüência de valores do mesmo tipo. Uma lista pode ser escrita colocando os elementos da seqüência entre colchetes e separados por vírgula. Exemplos: [False,True,False] :: [Bool] [ a, b, c, d ] :: [Char] ["bom","dia","brasil"] :: [String] [1,8,6,0,21] :: [Int] [3.4,5.6,3.213] :: [Double] [2%3,5%1,-6%10] :: [Rational] Em geral: [ t ] é o tipo das listas cujos elementos são do tipo t. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

8 Tipos listas (cont.) A lista vazia é escrita como [] O tipo de uma lista não diz nada sobre seu tamanho: [False,True] :: [Bool] [False,True,False] :: [Bool] O tipo dos elementos é irrestrito. Por exemplo, podemos ter listas de listas: [[False,True],[False,True,False]] :: [[Bool]] [[ a ],[ b, c ],[ %, * ],[]] :: [[Char]] [[[1,2,3],[10,20,30]],[[-1,-2]]] :: [[[Int]]] José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

9 Tipos tupla Uma tupla é uma seqüência de valores de diferentes tipos. Uma tupla é escrita colocando os elementos da seqüência entre parênteses e separados por vírgula. Exemplos: (False,True) :: (Bool,Bool) (False, a,true) :: (Bool,Char,Bool) ("Joel",16,5.34,True) :: (String,Int,Float,Bool) Em geral: ( t 1, t 2,..., t n ) é o tipo das n-uplas cujos i-ésimo componentes são do tipo t i, para qualquer i [1..n]. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

10 Tipos tupla (cont.) A tupla vazia é escrita como () e o seu tipo é (), chamado de unit. O tipo de uma tupla codifica o seu tamanho: (False,True) :: (Bool,Bool) (False,True,False) :: (Bool,Bool,Bool) O tipo dos componentes de uma tupla é irrestrito. Por exemplo: ( a,(false, b )) ::(Char,(Bool,Char)) (True,[ a, b ]) ::(Bool,[Char]) (5.6,("Ana",18), F ) ::(Double,(String,Int),Char) José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

11 Tipos tupla (cont.) Não há tuplas de um único elemento por questão de sintaxe, já que qualquer expressão pode ser escrita entre parênteses sem alterar o seu significado. ( a ) :: Char José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

12 Tipos função Uma função é um mapeamento de valores de um tipo para valores de outro tipo Exemplos de funções do prelúdio: not :: Bool -> Bool and :: [Bool] -> Bool or :: [Bool] -> Bool isdigit :: Char -> Bool Em geral: t 1 -> t 2 é o tipo das funções que mapeiam valores do tipo t 1 em valores do tipo t 2. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

13 Tipos função (cont.) Os tipos do argumento e do resultado são irrestritos. Por exemplo, funções com múltiplos argumentos ou resultados são possíveis usando listas ou tuplas: add :: (Int,Int) -> Int add (x,y) = x + y zeroto zeroto n :: Int -> [Int] = [0..n] José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

14 Funções curried Funções com múltiplos argumentos são também possíveis, retornando funções como resultados. Exemplo: add :: Int -> (Int -> Int) add x y = x + y add tem como argumento um inteiro x e retorna uma função add x. Por sua vez, esta função recebe um inteiro y e retorna o resultado x + y. add :: Int -> (Int -> Int) add x = add2 where add2 y = x + y José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

15 Funções curried (cont.) add e add produzem o mesmo resultado final, mas add recebe seus dois argumentos ao mesmo tempo, enquanto que add recebe-os um de cada vez. add :: (Int,Int) -> Int add :: Int -> (Int -> Int) Funções que recebem os seus argumentos um por vez são chamadas de funções curried, celebrando o trabalho de Haskell Curry em tais funções. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

16 Funções curried (cont.) Funções com mais de dois argumentos podem ser curried, retornando funções aninhadas. Exemplo: mult :: Int -> (Int -> (Int -> Int)) mult x y z = x * y * z mult recebe um inteiro x e retorna uma função mult x, que por sua vez recebe um y inteiro e retorna uma função mult x y, que finalmente recebe um z inteiro e retorna o resultado x * y * z. mult :: Int -> (Int -> (Int -> Int)) mult x = mult1 where mult1 y = mult2 where mult2 z = x * y * z José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

17 Por que currying é útil? Funções curried são mais flexíveis do que as funções em tuplas, porque funções úteis podem muitas vezes ser feitas pela aplicação parcial de uma função curried. Por exemplo: add 1 :: Int -> Int take 5 :: [Int] -> [Int] drop 5 :: [Int] -> [Int] José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

18 Convenções sobre currying Para evitar excesso de parênteses ao usar funções curried, duas convenções simples são adotadas: A seta -> associa à direita. Int -> Int -> Int -> Int significa Int -> (Int -> (Int -> Int)) José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

19 Convenções sobre currying (cont.) Como conseqüência, é então natural que a aplicação de função tem associatividade à esquerda. mult x y z significa ((mult x) y) z José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

20 Convenções sobre currying (cont.) A menos que seja explicitamente necessário o uso de tuplas, todas as funções em Haskell são normalmente definidas em forma de curried. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

21 Funções polimórficas Algumas funções podem operar sobre vários tipos de dados. Por exemplo: a função head recebe uma lista e retorna o primeiro elemento da lista: Prelude> head [ b, a, n, a, n, a ] b Prelude> head ["maria","paula","peixoto"] "maria" Prelude> head [True,False,True,True] True Prelude> head [("ana",2.8),("pedro",4.3)] ("ana",2.8) Não importa qual é o tipo dos elementos da lista. Qual é o tipo de head? José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

22 Funções polimórficas (cont.) Quando um tipo pode ser qualquer tipo da linguagem, ele é representado por uma variável de tipo. No exemplo dado, sendo a o tipo dos elementos da lista que é passada como argumento para a função head, então head :: [a] -> a a é uma variável de tipo e pode ser substituída por qualquer tipo. O tipo de head estabelece que head recebe uma lista com elementos de um tipo qualquer, e retorna um valor deste tipo. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

23 Funções polimórficas (cont.) Uma função é chamada polimórfica (de muitas formas) se o seu tipo contém uma ou mais variáveis de tipo. Exemplo: length :: [a] -> Int para qualquer tipo a, length recebe uma lista de valores do tipo a e retorna um inteiro. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

24 Funções polimórficas (cont.) As variaveis de tipo podem ser instanciadas para diferentes tipos em diferentes circunstâncias: > length [False,True] -- a = Bool 2 > length [1,2,3,4] -- a = Int 4 As variáveis de tipo devem começar com uma letra minúscula, e são geralmente denominadas a, b, c, etc. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

25 Funções polimórficas (cont.) Muitas das funções definidas no prelúdio padrão são polimórficas. Por exemplo: fst :: (a,b) -> a head :: [a] -> a take :: Int -> [a] -> [a] zip :: [a] -> [b] -> [(a,b)] id :: a -> a José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

26 Sobrecarga Uma função polimórfica é sobrecarregada se seu tipo contém uma ou mais restrições de classe. Exemplo: sum :: Num a => [a] -> a para qualquer tipo numérico sum, recebe uma lista de valores do tipo a e retorna um valor do tipo a. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

27 Sobrecarga (cont.) Variáveis de tipo restritas podem ser instanciadas para quaisquer tipos que satisfazer as restrições. Exemplo: > sum [1,2,3] -- a = Int 6 > sum [1.1,2.2,3.3] -- a = Float 6.6 > sum [ a, b, c ] -- Char não é um tipo numérico ERROR José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

28 Classes básicas Uma classe é uma coleção de de tipos que suportam certas operações sobrecarregadas chamadas métodos. Haskell tem várias classes de tipo pré-definidas. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

29 Classes básicas: Eq Formada pelos tipos cujos valores podem ser comparados por igualdade e desigualdade usando os métodos: (==) :: Eq a => a -> a -> Bool (/=) :: Eq a => a -> a -> Bool São instâncias de Eq: todos os tipos básicos Bool, Char, String, Int, Integer, Float, Double e Rational. todos os tipos listas cujo tipo dos elementos é instância de Eq todos os tipos tuplas cujos tipos dos componentes são todos instância de Eq Tipos função não são instâncias de Eq.q José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

30 Classes básicas: Eq (cont.) Exemplos: Prelude> a == b False Prelude> "abc" == "abc" True Prelude> [1,2] == [1,2,3] False Prelude> ( a,false) == ( a,false) True Prelude> (1,2) /= (2,1) True José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

31 Classes básicas: Ord Formada pelos tipos que são instâncias de Eq e cujos valores são ordenados totalmente (linearmente), podendo ser comparados usando os métodos: (<) :: Ord a => a -> a -> Bool (<=) :: Ord a => a -> a -> Bool (>) :: Ord a => a -> a -> Bool (>=) :: Ord a => a -> a -> Bool compare :: Ord a => a -> a -> Ordering min :: Ord a => a -> a -> a max :: Ord a => a -> a -> a O método compare recebe dois valores e retorna um resultado do tipo Ordering: GT, LT, EQ. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

32 Classes básicas: Ord (cont.) São instâncias de Ord: todos os tipos básicos Bool, Char, String, Int, Integer, Float, pyginline Double e Rational. todos os tipos listas cujo tipo dos elementos é instância de Ord todos os tipos tuplas cujos tipos dos componentes são todos instância de Ord Strings, listas e tuplas são ordenadas lexicograficamente (da mesma maneira que as palavras em um dicionário). José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

33 Classes básicas: Ord (cont.) Exemplos: Prelude> False < True True Prelude> min a b a Prelude> "elegante" < "elefante" False Prelude> [1,2,3] > [1,2] True Prelude> ( a,2) >= ( b,1) False Prelude> compare "Abracadabra" "Zebra" LT Prelude> compare 5 3 GT Prelude Data.Ratio> compare (4%5) (20%25) EQ José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

34 Classes básicas: Show Formada pelos tipos cujos valores podem ser convertidos para strings usando o método: show :: Show a => a -> String São instâncias de Show: todos os tipos básicos Bool, Char, String, Int, Integer, Float, Double e Rational. todos os tipos listas cujo tipo dos elementos é instância de Show todos os tipos tuplas cujos tipos dos componentes são todos instância de Show Tipos função não são instâncias de Show. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

35 Classes básicas: Show (cont.) Exemplos: Prelude> show False "False" Prelude> show a " a " Prelude> show 9172 "9172" Prelude> show [123,-764,0,18] "[123,-764,0,18]" Prelude> show ( a,true) "( a,true)" José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

36 Classes básicas: Read Formada pelos tipos cujos valores podem ser convertidos a partir de strings usando o método: read :: Read a => String -> a Read e Show são duais. São instâncias de Read: todos os tipos básicos Bool, Char, String, Int, Integer, Float, Double e Rational. todos os tipos listas cujo tipo dos elementos é instância de Read todos os tipos tuplas cujos tipos dos componentes são todos instância de Read Tipos função não são instâncias de Read. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

37 Classes básicas: Read (cont.) Exemplos: Prelude> read "False" :: Bool False Prelude> read " a " :: Char a Prelude> read "123" :: Int 123 Prelude> read "[1,2,3]" :: [Int] [1,2,3] Prelude> read "[1,2,3]" :: [Double] [1.0,2.0,3.0] Prelude> read "( a,false,5.6)" :: (Char,Bool,Double) ( a,false,5.6) Prelude> not (read "False") True Prelude> not (read "marcos") *** Exception: Prelude.read: no parse José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

38 Classes básicas: Read (cont.) Prelude> read "4" <interactive>:0:1: Ambiguous type variable a0 in the constraint: (Read a0) arising from a use of read Probable fix: add a type signature that fixes these type In the expression: read "4" In an equation for it : it = read "4" O uso de :: é necessário nestes exemplos para definir o tipo do resultado. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

39 Classes básicas: Enum Formada pelos tipos sequencialmente ordenados (cujos valores podem ser enumerados), podendo ser processados usando os métodos: succ :: Enum a => a -> a pred :: Enum a => a -> a toenum :: Enum a => Int -> a fromenum :: Enum a => a -> Int enumfrom :: Enum a => a -> [a] enumfromthen :: Enum a => a -> a -> [a] enumfromto :: Enum a => a -> a -> [a] enumfromthento :: Enum a => a -> a -> a -> [a] São instâncias de Enum os tipos básicos (), Bool, Char, Int, Integer, Float, Double, Rational e Ordering José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

40 Classes básicas: Enum (cont.) Exemplos: Prelude> succ Prelude> pred M L Prelude> fromenum A 65 Prelude> toenum 65 :: Char A Prelude> fromenum Prelude> toenum 5 :: Float 5.0 Prelude> fromenum True 1 Prelude> not (toenum 0) José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

41 Classes básicas: Enum (cont.) True Prelude> enumfromto 4 10 [4,5,6,7,8,9,10] Prelude> enumfromthento [4,7,10,13,16,19] Prelude> take 10 (enumfrom 100) [100,101,102,103,104,105,106,107,108,109] Prelude> take 10 (enumfromthen A C ) "ACEGIKMOQS" Prelude Data.Ratio> enumfromto (2%3) 5 [2 % 3,5 % 3,8 % 3,11 % 3,14 % 3] José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

42 Classes básicas: Bounded Formada pelos tipos que possuem um valor mínimo e um valor máximo, definidos pelos métodos: minbound :: Bounded a => a maxbound :: Bounded a => a São instâncias de Bounded os tipos básicos (), Bool, Char, Int, Ordering, e os tipos tuplas cujos componentes são de tipos que são instâncias de Bounded. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

43 Classes básicas: Bounded (cont.) Exemplos: Prelude> minbound :: Bool False Prelude> minbound :: Char \NUL Prelude> minbound :: Int Prelude> maxbound :: (Bool,Int,Ordering,()) (True, ,GT,()) José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

44 Classes básicas: Num Formada pelos tipos que são instâncias de Eq e Show e cujos valores são numéricos, podendo ser processados usando os métodos: (+) :: Num a => a -> a -> a (-) :: Num a => a -> a -> a (*) :: Num a => a -> a -> a negate :: Num a => a -> a abs :: Num a => a -> a signum :: Num a => a -> a São instâncias de Num os tipos básicos Int, Integer, Float, Double e Rational. Observe que a classe Num não oferece um método para divisão. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

45 Classes básicas: Num (cont.) Exemplos: Prelude> Prelude> Prelude> negate Prelude> abs (-3) 3 Prelude> signum (-3) -1 José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

46 Classes básicas: Real Formada pelos tipos que são instâncias de Num e Ord e cujos valores podem ser expressos como uma razão de dois números inteiros de precisão arbitrária através do método: torational :: Real a => a -> Rational Real é formada pelos tipos numéricos cujos valores podem ser comparados com (<) e demais operações relacionais da classe Ord. Nem todos os números podem ser comparados com (<), como por exemplo os números complexos. Todo número real de precisão finita pode ser expresso como um número racional. São instâncias de Real os tipos básicos Int, Integer, Float, Double e Rational. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

47 Classes básicas: Real (cont.) Exemplos: Prelude> torational % 1 Prelude> torational (-4.5) (-9) % 2 Prelude> torational % José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

48 Classes básicas: Integral Formada pelos tipos que são instâncias de Real e Enum, e cujos valores são números inteiros, suportando a operação de divisão inteira e podem ser processados usando os métodos: div :: Integral a => a -> a -> a mod :: Integral a => a -> a -> a divmod :: Integral a => a -> a -> (a, a) tointeger :: Integral a => a -> Integer São instâncias de Integral os tipos básicos Int e Integer. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

49 Classes básicas: Integral (cont.) Exemplos: Prelude> div Prelude> mod Prelude> divmod 20 3 (6,2) José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

50 Classes básicas: Integral (cont.) A função fromintegral :: (Integral a, Num b) => a -> b recebe um número integral e retorna este número convertido para um tipo numérico. Exemplo: Prelude> fromintegral 17 :: Double 17.0 Prelude> fromintegral (length [1,2,3,4]) José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

51 Classes básicas: Fractional Formada pelos tipos que são instâncias de Num e cujos valores não são números inteiros, suportando as operações de divisão fracionária e recíproco, usando os métodos: (/) :: Fractional a => a -> a -> a recip :: Fractional a => a -> a São instâncias de Fractional os tipos básicos Float, Double e Rational. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

52 Classes básicas: Fractional (cont.) Exemplos: Prelude> 7.0 / Prelude> recip José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

53 Classes básicas: Floating Formada pelos tipos que são instâncias de Fractional e cujos valores podem ser processados usando os métodos: pi :: Floating a => a exp :: Floating a => a -> a sqrt :: Floating a => a -> a log :: Floating a => a -> a (**) :: Floating a => a -> a -> a logbase :: Floating a => a -> a -> a sin :: Floating a => a -> a tan :: Floating a => a -> a cos :: Floating a => a -> a asin :: Floating a => a -> a atan :: Floating a => a -> a acos :: Floating a => a -> a sinh :: Floating a => a -> a José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

54 Classes básicas: Floating (cont.) tanh cosh asinh atanh acosh :: Floating a => a -> a :: Floating a => a -> a :: Floating a => a -> a :: Floating a => a -> a :: Floating a => a -> a São instâncias de Floating os tipos básicos Float e Double. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

55 Classes básicas: Floating (cont.) Exemplos: Prelude> pi Prelude> exp Prelude> sin (pi/2) 1.0 Prelude> atan (-1) Prelude> logbase José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

56 Classes básicas: RealFrac Formada pelos tipos que são instâncias de Real e Fractional (cujos valores não são números reais fracionários), e seus valores podem ser processados com os métodos: properfraction :: (RealFrac a, Integral b) => a -> (b,a) truncate :: (RealFrac a, Integral b) => a -> b round :: (RealFrac a, Integral b) => a -> b ceiling :: (RealFrac a, Integral b) => a -> b floor :: (RealFrac a, Integral b) => a -> b São instâncias de RealFrac os tipos básicos Float, Double e Rational. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

57 Classes básicas: RealFrac (cont.) Exemplos: Prelude Data.Ratio> truncate Prelude Data.Ratio> round Prelude Data.Ratio> ceiling Prelude Data.Ratio> floor Prelude Data.Ratio> properfraction (2, ) Prelude Data.Ratio> properfraction (9%4) (2,1 % 4) José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

58 Sobrecarga de literais Literais também podem ser sobrecarregados: 187 :: Num a => a :: Num a => a 3.4 :: Fractional a => a E13 :: Fractional a => a José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

59 Dicas e Sugestões Ao definir uma nova função em Haskell, é útil começar por escrever o seu tipo. Dentro de um script, é uma boa prática indicar o tipo de cada nova função definida. Ao indicar os tipos de funções polimórficas que usam números, igualdade, ou ordenações (ou outras resstrições), tome o cuidado de incluir as restrições de classe necessárias. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

60 Exercícios 1 Quais são os tipos dos valores a seguir? a) [ a, b, c ] b) ( a, b, c ) c) [(False, 0 ),(True, 1 )] d) ([False,True],[ 0, 1 ]) e) [tail,init,reverse] f) [] g) [[]] h) [[10,20,30],[],[5,6],[24]] i) (10e-2,20e-2,30e-3) j) [(2,3),(4,5.6),(6,4.55)] k) reverse l) [take 5,tail] m) (["bom","dia","brasil"],sum,drop 7) n) [sum,length] José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

61 Exercícios (cont.) 2 Quais são os tipos das seguintes funções? a) second xs = head (tail xs) b) swap (x,y) = (y,x) c) pair x y = (x,y) d) double x = x*2 e) palindrome xs = reverse xs == xs f) twice f x = f (f x) José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

62 Exercícios (cont.) 3 Verifique suas respostas aos exercícios anteriores usando o GHCi. José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63

63 Fim José Romildo Malaquias (UFOP) PF-03 Tipos e Classes / 63