aula3 tiposeclasses · programaçãofuncional aula3 tiposeclasses joséromildomalaquias...

Programação Funcional

Aula 3Tipos e Classes

José Romildo Malaquias

Departamento de ComputaçãoUniversidade Federal de Ouro Preto

2011.2

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

O que é um tipo?

I Um tipo é um nome para uma coleção de valoresrelacionados.

I Por exemplo, em Haskell o tipo básicoBoolcontém os dois valores lógicos:FalseTrue


Erros de tipo

I A aplicação de uma função a um ou mais argumentos dotipo errado constitui um erro de tipo.

I 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 + FalseIn an equation for ‘it’: it = 1 + False

1 é um número e False é um valor lógico, mas + requerdois números.


Tipos em Haskell

I Se a avaliação de uma expressão e produz um valor dotipo t, então o tipo de e é t, e escrevemos:e :: t

I Toda expressão bem formada tem um tipo, que pode sercalculado automaticamente em tempo de compilaçãousando um processo chamado inferência de tipos.


Tipos em Haskell (cont.)

I Todos os erros de tipo são encontrados em tempo decompilação, o que torna os programas mais seguros emais rápidos, eliminando a necessidade de verificaçõesde tipo em tempo de execução.

I No GHCi, o comando :type calcula o tipo de umaexpressão, sem avaliá-la:Prelude> not FalseTruePrelude> :type not Falsenot False :: BoolPrelude>


Tipos básicos

Haskell tem um número de tipos básicos, incluindo:

Bool valores lógicosChar caracteres simplesString seqüências de caracteresInt inteiros de precisão fixaInteger inteiros de precisão arbitráriaFloat núm. em ponto flutuante com precisão simplesDouble núm. em ponto flutuante com precisão duplaRational números racionais de precisão arbitrária


Tipos listas

I Uma lista é uma seqüência de valores do mesmo tipo.I Uma lista pode ser escrita colocando os elementos daseqüência entre colchetes e separados por vírgula.

I 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]

I Em geral:[ t ]é o tipo das listas cujos elementos são do tipo t.


Tipos listas (cont.)

I A lista vazia é escrita como[]

I O tipo de uma lista não diz nada sobre seu tamanho:[False,True] :: [Bool][False,True,False] :: [Bool]

I O tipo dos elementos é irrestrito. Por exemplo, podemoster listas de listas:[[False,True],[False,True,False]] :: [[Bool]][[’a’],[’b’,’c’],[’%’,’*’],[]] :: [[Char]][[[1,2,3],[10,20,30]],[[-1,-2]]] :: [[[Int]]]


Tipos tupla

I Uma tupla é uma seqüência de valores de diferentestipos.

I Uma tupla é escrita colocando os elementos da seqüênciaentre parênteses e separados por vírgula.

I Exemplos:(False,True) :: (Bool,Bool)(False,’a’,True) :: (Bool,Char,Bool)("Joel",16,5.34,True) :: (String,Int,Float,Bool)

I Em geral:( t1, t2, ..., tn )é o tipo das n-uplas cujos i-ésimo componentes são dotipo ti, para qualquer i ∈ [1..n].


Tipos tupla (cont.)

I A tupla vazia é escrita como () e o seu tipo é () ,chamado de unit.

I O tipo de uma tupla codifica o seu tamanho:(False,True) :: (Bool,Bool)(False,True,False) :: (Bool,Bool,Bool)

I O tipo dos componentes de uma tupla é irrestrito. Porexemplo:(’a’,(False,’b’)) ::(Char,(Bool,Char))(True,[’a’,’b’]) ::(Bool,[Char])(5.6,("Ana",18),’F’) ::(Double,(String,Int),Char)


Tipos tupla (cont.)

I Não há tuplas de um único elemento por questão desintaxe, já que qualquer expressão pode ser escrita entreparênteses sem alterar o seu significado.(’a’) :: Char


Tipos função

I Uma função é um mapeamento de valores de um tipopara valores de outro tipo

I Exemplos de funções do prelúdio:not :: Bool -> Booland :: [Bool] -> Boolor :: [Bool] -> BoolisDigit :: Char -> Bool

I Em geral:t1 -> t2é o tipo das funções que mapeiam valores do tipo t1 emvalores do tipo t2.


Tipos função (cont.)

I Os tipos do argumento e do resultado são irrestritos. Porexemplo, funções com múltiplos argumentos ouresultados são possíveis usando listas ou tuplas:add :: (Int,Int) -> Intadd (x,y) = x + y

zeroto :: Int -> [Int]zeroto n = [0..n]


Funções curried

I Funções com múltiplos argumentos são tambémpossíveis, retornando funções como resultados.

I Exemplo:add’ :: Int -> (Int -> Int)add’ x y = x + yadd’ tem como argumento um inteiro x e retorna umafunção add’ x. Por sua vez, esta função recebe um inteiroy e retorna o resultado x + y.add’ :: Int -> (Int -> Int)add’ x = add2

whereadd2 y = x + y


Funções curried (cont.)

I add e add’ produzem o mesmo resultado final, mas addrecebe seus dois argumentos ao mesmo tempo, enquantoque add’ recebe-os um de cada vez.add :: (Int,Int) -> Intadd’ :: Int -> (Int -> Int)

I Funções que recebem os seus argumentos um por vez sãochamadas de funções curried, celebrando o trabalho deHaskell Curry em tais funções.


Funções curried (cont.)

I Funções com mais de dois argumentos podem ser curried,retornando funções aninhadas.

I Exemplo:mult :: Int -> (Int -> (Int -> Int))mult x y z = x * y * zmult recebe um inteiro x e retorna uma função mult x,que por sua vez recebe um y inteiro e retorna uma funçãomult x y, que finalmente recebe um z inteiro e retorna oresultado x * y * z.mult :: Int -> (Int -> (Int -> Int))mult x = mult1

where mult1 y = mult2where mult2 z = x * y * z


Por que currying é útil?

I Funções curried são mais flexíveis do que as funções emtuplas, porque funções úteis podem muitas vezes serfeitas pela aplicação parcial de uma função curried.

I Por exemplo:add’ 1 :: Int -> Inttake 5 :: [Int] -> [Int]drop 5 :: [Int] -> [Int]


Convenções sobre currying

I Para evitar excesso de parênteses ao usar funçõescurried, duas convenções simples são adotadas:

I A seta -> associa à direita.Int -> Int -> Int -> IntsignificaInt -> (Int -> (Int -> Int))


Convenções sobre currying (cont.)

I Como conseqüência, é então natural que a aplicação defunção tem associatividade à esquerda.mult x y zsignifica((mult x) y) z


Convenções sobre currying (cont.)

I A menos que seja explicitamente necessário o uso detuplas, todas as funções em Haskell são normalmentedefinidas em forma de curried.


Funções polimórficasI Algumas funções podem operar sobre vários tipos dedados.

I Por exemplo: a função head recebe uma lista e retorna oprimeiro elemento da lista:Prelude> head [’b’,’a’,’n’,’a’,’n’,’a’]’b’Prelude> head ["maria","paula","peixoto"]"maria"Prelude> head [True,False,True,True]TruePrelude> 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?


Funções polimórficas (cont.)

I Quando um tipo pode ser qualquer tipo da linguagem, eleé representado por uma variável de tipo.

I No exemplo dado, sendo a o tipo dos elementos da listaque é passada como argumento para a função head,entãohead :: [a] -> aa é uma variável de tipo e pode ser substituída porqualquer tipo.O tipo de head estabelece que head recebe uma lista comelementos de um tipo qualquer, e retorna um valor destetipo.



I Uma função é chamada polimórfica (de muitas formas)se o seu tipo contém uma ou mais variáveis de tipo.

I Exemplo:length :: [a] -> Intpara qualquer tipo a, length recebe uma lista de valoresdo tipo a e retorna um inteiro.



I As variaveis de tipo podem ser instanciadas paradiferentes tipos em diferentes circunstâncias:> length [False,True] -- a = Bool2

> length [1,2,3,4] -- a = Int4

I As variáveis de tipo devem começar com uma letraminúscula, e são geralmente denominadas a, b, c, etc.



I Muitas das funções definidas no prelúdio padrão sãopolimórficas. Por exemplo:fst :: (a,b) -> ahead :: [a] -> atake :: Int -> [a] -> [a]zip :: [a] -> [b] -> [(a,b)]id :: a -> a


Sobrecarga

I Uma função polimórfica é sobrecarregada se seu tipocontém uma ou mais restrições de classe.

I Exemplo:sum :: Num a => [a] -> a

para qualquer tipo numérico sum, recebe uma listade valores do tipo a e retorna um valor do tipo a.


Sobrecarga (cont.)

I Variáveis de tipo restritas podem ser instanciadas paraquaisquer tipos que satisfazer as restrições.

I Exemplo:> sum [1,2,3] -- a = Int6

> sum [1.1,2.2,3.3] -- a = Float6.6

> sum [’a’,’b’,’c’] -- Char não é um tipo numéricoERROR


Classes básicas

I Uma classe é uma coleção de de tipos que suportamcertas operações sobrecarregadas chamadas métodos.

I Haskell tem várias classes de tipo pré-definidas.


Classes básicas: Eq

I Formada pelos tipos cujos valores podem ser comparadospor igualdade e desigualdade usando os métodos:(==) :: Eq a => a -> a -> Bool(/=) :: Eq a => a -> a -> Bool

I 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 deEqtodos os tipos tuplas cujos tipos dos componentes sãotodos instância de Eq

I Tipos função não são instâncias de Eq.q


Classes básicas: Eq (cont.)

I Exemplos:Prelude> ’a’ == ’b’FalsePrelude> "abc" == "abc"TruePrelude> [1,2] == [1,2,3]FalsePrelude> (’a’,False) == (’a’,False)TruePrelude> (1,2) /= (2,1)True


Classes básicas: Ord

I Formada pelos tipos que são instâncias de Eq e cujosvalores são ordenados totalmente (linearmente), podendoser comparados usando os métodos:(<) :: Ord a => a -> a -> Bool(<=) :: Ord a => a -> a -> Bool(>) :: Ord a => a -> a -> Bool(>=) :: Ord a => a -> a -> Boolcompare :: Ord a => a -> a -> Orderingmin :: Ord a => a -> a -> amax :: Ord a => a -> a -> a

I O método compare recebe dois valores e retorna umresultado do tipo Ordering: GT, LT, EQ.


Classes básicas: Ord (cont.)

I 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 deOrdtodos os tipos tuplas cujos tipos dos componentes sãotodos instância de Ord

I Strings, listas e tuplas são ordenadas lexicograficamente(da mesma maneira que as palavras em um dicionário).


Classes básicas: Ord (cont.)I Exemplos:

Prelude> False < TrueTruePrelude> min ’a’ ’b’’a’Prelude> "elegante" < "elefante"FalsePrelude> [1,2,3] > [1,2]TruePrelude> (’a’,2) >= (’b’,1)FalsePrelude> compare "Abracadabra" "Zebra"LTPrelude> compare 5 3GTPrelude Data.Ratio> compare (4%5) (20%25)EQ


Classes básicas: Show

I Formada pelos tipos cujos valores podem ser convertidospara strings usando o método:show :: Show a => a -> String

I 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 deShowtodos os tipos tuplas cujos tipos dos componentes sãotodos instância de Show

I Tipos função não são instâncias de Show.


Classes básicas: Show (cont.)

I 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)"


Classes básicas: Read

I Formada pelos tipos cujos valores podem ser convertidosa partir de strings usando o método:read :: Read a => String -> a

I Read e Show são duais.I 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 deReadtodos os tipos tuplas cujos tipos dos componentes sãotodos instância de Read

I Tipos função não são instâncias de Read.


Classes básicas: Read (cont.)I Exemplos:

Prelude> read "False" :: BoolFalsePrelude> read "’a’" :: Char’a’Prelude> read "123" :: Int123Prelude> 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")TruePrelude> not (read "marcos")*** Exception: Prelude.read: no parse


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 variable(s)In the expression: read "4"In an equation for ‘it’: it = read "4"

I O uso de :: é necessário nestes exemplos para definir otipo do resultado.


Classes básicas: Enum

I Formada pelos tipos sequencialmente ordenados (cujosvalores podem ser enumerados), podendo serprocessados usando os métodos:succ :: Enum a => a -> apred :: Enum a => a -> atoEnum :: Enum a => Int -> afromEnum :: Enum a => a -> IntenumFrom :: Enum a => a -> [a]enumFromThen :: Enum a => a -> a -> [a]enumFromTo :: Enum a => a -> a -> [a]enumFromThenTo :: Enum a => a -> a -> a -> [a]

I São instâncias de Enum os tipos básicos (), Bool, Char,Int, Integer, Float, Double, Rational e Ordering


Classes básicas: Enum (cont.)I Exemplos:

Prelude> succ 5657Prelude> pred ’M’’L’Prelude> fromEnum ’A’65Prelude> toEnum 65 :: Char’A’Prelude> fromEnum 5.65Prelude> toEnum 5 :: Float5.0Prelude> fromEnum True1Prelude> not (toEnum 0)


Classes básicas: Enum (cont.)

TruePrelude> enumFromTo 4 10[4,5,6,7,8,9,10]Prelude> enumFromThenTo 4 7 20[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]


Classes básicas: Bounded

I Formada pelos tipos que possuem um valor mínimo e umvalor máximo, definidos pelos métodos:minBound :: Bounded a => amaxBound :: Bounded a => a

I São instâncias de Bounded os tipos básicos (), Bool,Char, Int, Ordering, e os tipos tuplas cujos componentessão de tipos que são instâncias de Bounded.


Classes básicas: Bounded (cont.)

I Exemplos:Prelude> minBound :: BoolFalsePrelude> minBound :: Char’\NUL’Prelude> minBound :: Int-9223372036854775808Prelude> maxBound :: (Bool,Int,Ordering,())(True,9223372036854775807,GT,())


Classes básicas: Num

I Formada pelos tipos que são instâncias de Eq e Show ecujos valores são numéricos, podendo ser processadosusando os métodos:(+) :: Num a => a -> a -> a(-) :: Num a => a -> a -> a(*) :: Num a => a -> a -> anegate :: Num a => a -> aabs :: Num a => a -> asignum :: Num a => a -> a

I São instâncias de Num os tipos básicos Int, Integer,Float, Double e Rational.

I Observe que a classe Num não oferece um método paradivisão.


Classes básicas: Num (cont.)

I Exemplos:Prelude> 1 + 23Prelude> 1.1 + 2.23.3000000000000003Prelude> negate 3.3-3.3Prelude> abs (-3)3Prelude> signum (-3)-1


Classes básicas: Real

I Formada pelos tipos que são instâncias de Num e Ord ecujos valores podem ser expressos como uma razão dedois números inteiros de precisão arbitrária através dométodo:toRational :: Real a => a -> Rational

I Real é formada pelos tipos numéricos cujos valorespodem ser comparados com (<) e demais operaçõesrelacionais da classe Ord.

I Nem todos os números podem ser comparados com (<),como por exemplo os números complexos.

I Todo número real de precisão finita pode ser expressocomo um número racional.

I São instâncias de Real os tipos básicos Int, Integer,Float, Double e Rational.


Classes básicas: Real (cont.)

I Exemplos:Prelude> toRational 4545 % 1Prelude> toRational (-4.5)(-9) % 2Prelude> toRational 6.77543529375845581 % 1125899906842624


Classes básicas: Integral

I Formada pelos tipos que são instâncias de Real e Enum, ecujos valores são números inteiros, suportando aoperação de divisão inteira e podem ser processadosusando os métodos:div :: Integral a => a -> a -> amod :: Integral a => a -> a -> adivMod :: Integral a => a -> a -> (a, a)toInteger :: Integral a => a -> Integer

I São instâncias de Integral os tipos básicos Int eInteger.


Classes básicas: Integral (cont.)

I Exemplos:Prelude> div 7 23Prelude> mod 7 21Prelude> divMod 20 3(6,2)


Classes básicas: Integral (cont.)

I A funçãofromIntegral :: (Integral a, Num b) => a -> brecebe um número integral e retorna este númeroconvertido para um tipo numérico.

I Exemplo:Prelude> fromIntegral 17 :: Double17.0Prelude> fromIntegral (length [1,2,3,4]) + 3.27.2


Classes básicas: Fractional

I Formada pelos tipos que são instâncias de Num e cujosvalores não são números inteiros, suportando asoperações de divisão fracionária e recíproco, usando osmétodos:(/) :: Fractional a => a -> a -> arecip :: Fractional a => a -> a

I São instâncias de Fractional os tipos básicos Float,Double e Rational.


Classes básicas: Fractional (cont.)

I Exemplos:Prelude> 7.0 / 2.03.5Prelude> recip 2.00.5


Classes básicas: Floating

I Formada pelos tipos que são instâncias de Fractional ecujos valores podem ser processados usando os métodos:pi :: Floating a => aexp :: Floating a => a -> asqrt :: Floating a => a -> alog :: Floating a => a -> a(**) :: Floating a => a -> a -> alogBase :: Floating a => a -> a -> asin :: Floating a => a -> atan :: Floating a => a -> acos :: Floating a => a -> aasin :: Floating a => a -> aatan :: Floating a => a -> aacos :: Floating a => a -> asinh :: Floating a => a -> a


Classes básicas: Floating (cont.)

tanh :: Floating a => a -> acosh :: Floating a => a -> aasinh :: Floating a => a -> aatanh :: Floating a => a -> aacosh :: Floating a => a -> a

I São instâncias de Floating os tipos básicos Float eDouble.


Classes básicas: Floating (cont.)

I Exemplos:Prelude> pi3.141592653589793Prelude> exp 12.718281828459045Prelude> sin (pi/2)1.0Prelude> atan (-1)-0.7853981633974483Prelude> logBase 10 1002.0


Classes básicas: RealFrac

I Formada pelos tipos que são instâncias de Real eFractional (cujos valores não são números reaisfracionários), e seus valores podem ser processados comos métodos:properFraction :: (RealFrac a, Integral b) => a -> (b,a)truncate :: (RealFrac a, Integral b) => a -> bround :: (RealFrac a, Integral b) => a -> bceiling :: (RealFrac a, Integral b) => a -> bfloor :: (RealFrac a, Integral b) => a -> b

I São instâncias de RealFrac os tipos básicos Float,Double e Rational.


Classes básicas: RealFrac (cont.)

I Exemplos:Prelude Data.Ratio> truncate 2.7562Prelude Data.Ratio> round 2.7563Prelude Data.Ratio> ceiling 2.7563Prelude Data.Ratio> floor 2.7562Prelude Data.Ratio> properFraction 2.756(2,0.7559999999999998)Prelude Data.Ratio> properFraction (9%4)(2,1 % 4)


Sobrecarga de literais

Literais também podem ser sobrecarregados:187 :: Num a => a-5348 :: Num a => a3.4 :: Fractional a => a-56.78E13 :: Fractional a => a


Dicas e Sugestões

I Ao definir uma nova função em Haskell, é útil começar porescrever o seu tipo.

I Dentro de um script, é uma boa prática indicar o tipo decada nova função definida.

I Ao indicar os tipos de funções polimórficas que usamnúmeros, igualdade, ou ordenações (ou outrasresstrições), tome o cuidado de incluir as restrições declasse necessárias.


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) reversel) [take 5,tail]

m) (["bom","dia","brasil"],sum,drop 7)n) [sum,length]


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*2e) palindrome xs = reverse xs == xsf) twice f x = f (f x)


Exercícios (cont.)

3 Verifique suas respostas aos exercícios anteriores usandoo GHCi.


Fim


aula3 tiposeclasses · programaçãofuncional aula3 tiposeclasses joséromildomalaquias...

Documents