Programação Funcional
Aula 3
Tipos e Classes
José Romildo Malaquias
Departamento de Computação
Universidade 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 valores
relacionados.
I
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
2011.2
2 / 63
Erros de tipo
I
A aplicação de uma função a um ou mais argumentos do
tipo 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 + 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
2011.2
3 / 63
Tipos em Haskell
I
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
I
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
2011.2
4 / 63
Tipos em Haskell (cont.)
I
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.
I
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
2011.2
5 / 63
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
2011.2
6 / 63
Tipos listas
I
Uma lista é uma seqüência de valores do mesmo tipo.
I
Uma lista pode ser escrita colocando os elementos da
seqüência entre colchetes e separados por vírgula.
I
Exemplos:
[False,True,False]
[’a’,’b’,’c’,’d’]
["bom","dia","Brasil"]
[1,8,6,0,21]
[3.4,5.6,3.213]
[2%3,5%1,-6%10]
I
::
::
::
::
::
::
[Bool]
[Char]
[String]
[Int]
[Double]
[Rational]
Em geral:
[ t ]
é o tipo das listas cujos elementos são do tipo t.
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
7 / 63
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, 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
2011.2
8 / 63
Tipos tupla
I
Uma tupla é uma seqüência de valores de diferentes
tipos.
I
Uma tupla é escrita colocando os elementos da seqüência
entre 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 do
tipo ti , para qualquer i ∈ [1..n].
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
9 / 63
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. 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
2011.2
10 / 63
Tipos tupla (cont.)
I
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
2011.2
11 / 63
Tipos função
I
Uma função é um mapeamento de valores de um tipo
para valores de outro tipo
I
Exemplos de
not
::
and
::
or
::
isDigit ::
I
Em geral:
t1 -> t2
funções do prelúdio:
Bool -> Bool
[Bool] -> Bool
[Bool] -> Bool
Char -> Bool
é o tipo das funções que mapeiam valores do tipo t1 em
valores do tipo t2 .
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
12 / 63
Tipos função (cont.)
I
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
2011.2
13 / 63
Funções curried
I
Funções com múltiplos argumentos são também
possíveis, retornando funções como resultados.
I
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
2011.2
14 / 63
Funções curried (cont.)
I
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)
I
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
2011.2
15 / 63
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 * 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
2011.2
16 / 63
Por que currying é útil?
I
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.
I
Por exemplo:
add’ 1 :: Int -> Int
take 5 :: [Int] -> [Int]
drop 5 :: [Int] -> [Int]
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
17 / 63
Convenções sobre currying
I
Para evitar excesso de parênteses ao usar funções
curried, duas convenções simples são adotadas:
I
A seta -> associa à direita.
Int -> Int -> Int -> Int
significa
Int -> (Int -> (Int -> Int))
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
18 / 63
Convenções sobre currying (cont.)
I
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
2011.2
19 / 63
Convenções sobre currying (cont.)
I
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
2011.2
20 / 63
Funções polimórficas
I
Algumas funções podem operar sobre vários tipos de
dados.
I
Por exemplo: a função head recebe uma lista e retorna o
primeiro elemento da lista:
Prelude> head
’b’
Prelude> head
"maria"
Prelude> head
True
Prelude> head
("ana",2.8)
[’b’,’a’,’n’,’a’,’n’,’a’]
["maria","paula","peixoto"]
[True,False,True,True]
[("ana",2.8),("pedro",4.3)]
Não importa qual é o tipo dos elementos da lista.
Qual é o tipo de head?
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
21 / 63
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 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
2011.2
22 / 63
Funções polimórficas (cont.)
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] -> 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
2011.2
23 / 63
Funções polimórficas (cont.)
I
I
As variaveis de tipo podem ser instanciadas para
diferentes tipos em diferentes circunstâncias:
> length [False,True]
2
-- a = Bool
> length [1,2,3,4]
4
-- a = Int
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
2011.2
24 / 63
Funções polimórficas (cont.)
I
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
2011.2
25 / 63
Sobrecarga
I
Uma função polimórfica é sobrecarregada se seu tipo
contém uma ou mais restrições de classe.
I
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
2011.2
26 / 63
Sobrecarga (cont.)
I
Variáveis de tipo restritas podem ser instanciadas para
quaisquer tipos que satisfazer as restrições.
I
Exemplo:
> sum [1,2,3]
6
-- a = Int
> sum [1.1,2.2,3.3]
6.6
-- a = Float
> sum [’a’,’b’,’c’]
ERROR
-- Char não é um tipo numérico
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
27 / 63
Classes básicas
I
Uma classe é uma coleção de de tipos que suportam
certas operações sobrecarregadas chamadas métodos.
I
Haskell tem várias classes de tipo pré-definidas.
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
28 / 63
Classes básicas: Eq
I
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
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 de
Eq
todos os tipos tuplas cujos tipos dos componentes são
todos instância de Eq
I
Tipos função não são instâncias de Eq.q
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
29 / 63
Classes básicas: Eq (cont.)
I
Exemplos:
Prelude>
False
Prelude>
True
Prelude>
False
Prelude>
True
Prelude>
True
’a’ == ’b’
"abc" == "abc"
[1,2] == [1,2,3]
(’a’,False) == (’a’,False)
(1,2) /= (2,1)
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
30 / 63
Classes básicas: Ord
I
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
I
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
2011.2
31 / 63
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 de
Ord
todos os tipos tuplas cujos tipos dos componentes são
todos instância de Ord
I
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
2011.2
32 / 63
Classes básicas: Ord (cont.)
I
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
2011.2
33 / 63
Classes básicas: Show
I
Formada pelos tipos cujos valores podem ser convertidos
para 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 de
Show
todos os tipos tuplas cujos tipos dos componentes são
todos instância de Show
I
Tipos função não são instâncias de Show.
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
34 / 63
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)"
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
35 / 63
Classes básicas: Read
I
Formada pelos tipos cujos valores podem ser convertidos
a partir de strings usando o método:
read :: Read a => String -> a
I
Read e Show são duais.
São instâncias de Read:
I
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
I
Tipos função não são instâncias de Read.
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
36 / 63
Classes básicas: Read (cont.)
I
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
2011.2
37 / 63
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"
I
O uso de :: é necessário nestes exemplos para definir o
tipo do resultado.
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
38 / 63
Classes básicas: Enum
I
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]
I
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
2011.2
39 / 63
Classes básicas: Enum (cont.)
I
Exemplos:
Prelude>
57
Prelude>
’L’
Prelude>
65
Prelude>
’A’
Prelude>
5
Prelude>
5.0
Prelude>
1
Prelude>
succ 56
pred ’M’
fromEnum ’A’
toEnum 65 :: Char
fromEnum 5.6
toEnum 5 :: Float
fromEnum True
not (toEnum 0)
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
40 / 63
Classes básicas: Enum (cont.)
True
Prelude> 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]
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
41 / 63
Classes básicas: Bounded
I
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
I
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
2011.2
42 / 63
Classes básicas: Bounded (cont.)
I
Exemplos:
Prelude> minBound :: Bool
False
Prelude> minBound :: Char
’\NUL’
Prelude> minBound :: Int
-9223372036854775808
Prelude> maxBound :: (Bool,Int,Ordering,())
(True,9223372036854775807,GT,())
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
43 / 63
Classes básicas: Num
I
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
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 para
divisão.
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
44 / 63
Classes básicas: Num (cont.)
I
Exemplos:
Prelude> 1 + 2
3
Prelude> 1.1 + 2.2
3.3000000000000003
Prelude> negate 3.3
-3.3
Prelude> abs (-3)
3
Prelude> signum (-3)
-1
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
45 / 63
Classes básicas: Real
I
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
I
Real é formada pelos tipos numéricos cujos valores
podem ser comparados com (<) e demais operações
relacionais 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 expresso
como um número racional.
I
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
2011.2
46 / 63
Classes básicas: Real (cont.)
I
Exemplos:
Prelude> toRational 45
45 % 1
Prelude> toRational (-4.5)
(-9) % 2
Prelude> toRational 6.7
7543529375845581 % 1125899906842624
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
47 / 63
Classes básicas: Integral
I
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
I
São instâncias de Integral os tipos básicos Int e
Integer.
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
48 / 63
Classes básicas: Integral (cont.)
I
Exemplos:
Prelude> div 7 2
3
Prelude> mod 7 2
1
Prelude> divMod 20 3
(6,2)
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
49 / 63
Classes básicas: Integral (cont.)
I
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.
I
Exemplo:
Prelude> fromIntegral 17 :: Double
17.0
Prelude> fromIntegral (length [1,2,3,4]) + 3.2
7.2
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
50 / 63
Classes básicas: Fractional
I
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
I
São instâncias de Fractional os tipos básicos Float,
Double e Rational.
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
51 / 63
Classes básicas: Fractional (cont.)
I
Exemplos:
Prelude> 7.0 / 2.0
3.5
Prelude> recip 2.0
0.5
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
52 / 63
Classes básicas: Floating
I
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
2011.2
53 / 63
Classes básicas: Floating (cont.)
tanh
cosh
asinh
atanh
acosh
I
::
::
::
::
::
Floating
Floating
Floating
Floating
Floating
a
a
a
a
a
=>
=>
=>
=>
=>
a
a
a
a
a
->
->
->
->
->
a
a
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
2011.2
54 / 63
Classes básicas: Floating (cont.)
I
Exemplos:
Prelude> pi
3.141592653589793
Prelude> exp 1
2.718281828459045
Prelude> sin (pi/2)
1.0
Prelude> atan (-1)
-0.7853981633974483
Prelude> logBase 10 100
2.0
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
55 / 63
Classes básicas: RealFrac
I
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
truncate
round
ceiling
floor
I
::
::
::
::
::
(RealFrac
(RealFrac
(RealFrac
(RealFrac
(RealFrac
a,
a,
a,
a,
a,
Integral
Integral
Integral
Integral
Integral
b)
b)
b)
b)
b)
=>
=>
=>
=>
=>
a
a
a
a
a
->
->
->
->
->
(b,a)
b
b
b
b
São instâncias de RealFrac os tipos básicos Float,
Double e Rational.
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
56 / 63
Classes básicas: RealFrac (cont.)
I
Exemplos:
Prelude Data.Ratio> truncate 2.756
2
Prelude Data.Ratio> round 2.756
3
Prelude Data.Ratio> ceiling 2.756
3
Prelude Data.Ratio> floor 2.756
2
Prelude Data.Ratio> properFraction 2.756
(2,0.7559999999999998)
Prelude Data.Ratio> properFraction (9%4)
(2,1 % 4)
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
57 / 63
Sobrecarga de literais
Literais também podem ser sobrecarregados:
187
:: Num a => a
-5348
:: Num a => a
3.4
:: Fractional a => a
-56.78E13 :: Fractional a => a
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
58 / 63
Dicas e Sugestões
I
Ao definir uma nova função em Haskell, é útil começar por
escrever o seu tipo.
I
Dentro de um script, é uma boa prática indicar o tipo de
cada nova função definida.
I
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
2011.2
59 / 63
Exercícios
1
Quais são os tipos dos valores a seguir?
a)
b)
c)
d)
e)
f)
g)
h)
i)
j)
k)
l)
m)
n)
[’a’,’b’,’c’]
(’a’,’b’,’c’)
[(False,’0’),(True,’1’)]
([False,True],[’0’,’1’])
[tail,init,reverse]
[]
[[]]
[[10,20,30],[],[5,6],[24]]
(10e-2,20e-2,30e-3)
[(2,3),(4,5.6),(6,4.55)]
reverse
[take 5,tail]
(["bom","dia","brasil"],sum,drop 7)
[sum,length]
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
60 / 63
Exercícios (cont.)
2
Quais são os tipos das seguintes funções?
a)
b)
c)
d)
e)
f)
second xs
=
swap (x,y)
=
pair x y
=
double x
=
palindrome xs =
twice f x
=
José Romildo Malaquias (UFOP)
head (tail xs)
(y,x)
(x,y)
x*2
reverse xs == xs
f (f x)
PF-03 Tipos e Classes
2011.2
61 / 63
Exercícios (cont.)
3
Verifique suas respostas aos exercícios anteriores usando
o GHCi.
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
62 / 63
Fim
José Romildo Malaquias (UFOP)
PF-03 Tipos e Classes
2011.2
63 / 63