Types Haskell

Declaracao de tipos e classes
Universidade de Braslia
Rodrigo Bonifacio
26 de abril de 2012
Rodrigo Bonifacio Declara cao de tipos e classes
Relembrando . . .
Um tipo e uma colecao de valores relacionados.
O tipo Bool
contem os valores logicos True e False; enquanto que o tipo
Bool Bool contem todas as func oes que mapeiam valores
booleanos em resultados tambem do tipo booleando.
Em Haskell, toda expressao deve ter um tipo, que e calculado
antes de avaliar a expressao por um processo chamado de
inferencia de tipos.
Relembrando . . .
Um tipo e uma colecao de valores relacionados. O tipo Bool
contem os valores logicos True e False
; enquanto que o tipo
Relembrando . . .
Relembrando . . .
Declaracao de sin onimos de tipos
Mecanismo usado para declarar um novo nome para um tipo
existente, sendo util para melhorar a compreensao do codigo.
type Side = Float
type Radius = Float
type Vertex = (Float, Float)
Sinonimos nao podem ser recursivos
(para criarmos tipos
recursivos, precisamos denir novos tipos usando a construcao
data.)
Por outro lado, type synonymous podem ser parametrizados:
Parser a = String -> [(a, String)]
type Side = Float
type Radius = Float
Sinonimos nao podem ser recursivos (para criarmos tipos
data.)
type Side = Float
type Radius = Float
Sinonimos nao podem ser recursivos (para criarmos tipos
data.)
Declaracao de novos tipos
Novos tipos podem ser criados usando a constru cao data.
data Shape = Rectangle Side Side
| Ellipse Radius Radius
| RtTriangle Side Side
| Polygon [Vertex]
Nesse caso, indicamos que um Shape pode ser um retangulo,
uma elipse, um triangulo retangulo ou um polgono.
Rectangle, Ellipse, RtTriangle, Polygon podem ser vistos como
tipos especiais de funcoes que servem para construir instancias
do tipo Shape sao construtores do tipo Shape.
| Polygon [Vertex]
| Polygon [Vertex]
do tipo Shape
sao construtores do tipo Shape.
| Polygon [Vertex]
Valores de tipos denidos pelos usuarios podem ser
usados da mesma forma que os valores dos tipos
pre-denidos; ou seja, podemos, por exemplo,
denir funcoes que recebem Shapes como
argumento ou que retornam valores do tipo Shape.
Novos tipos podem ser parametrizados
Uniformidade e uma caracterstica da linguagem
Haskell
data Maybe a = Nothing | Just a
O tipo Maybe e util para lidar com algumas situacoes de erro.
safediv :: Integer -> Integer -> Maybe Integer
safediv _ 0 = Nothing
safediv m n = Just (m div n)
safehead :: [a] -> Maybe a
safehead [] = Nothing
safehead (x:xs) = Just x
Haskell
Haskell
Conforme mencionado, tipos denidos pelos
usuarios podem ser recursivos
Por exemplo, listas e arvores tem deni coes recursivas
Implementacao de listas e arvore binaria:
data List a = Nil
| Cons a (List a)
data BTree a = Leaf a
| Node BTree a BTree
Podemos ter fun coes para vericar se um elemento existe na
arvore ou para transformar uma arvore em lista:
occurs :: a -> BTree a -> Bool
occurs _ Leaf = False
occurs m (Node l i r) =
if (i == m)
then True
else (occurs m l) || (occurs m r)
flatten :: BTree a -> [Int]
flatten Leaf = []
flatten (Node l i r) = i : (flatten l ++ flatten r)
Arvores sao frequentemente usadas para representar

linguagens
os componentes de front-end dos
compiladores usualmente geram arvores sintaticas
apropriadas para manipulacao.
Arvores sao frequentemente usadas para representar

linguagens os componentes de front-end dos
compiladores usualmente geram arvores sintaticas
apropriadas para manipulacao.
Como representar express oes aritmeticas simples?
data Exp = Val Int
| Add Exp Exp
| Sub Exp Exp
O tipo Exp segue uma estrutura de arvore (um pouco
diferente da que ilustramos anteriormente, mas e uma arvore.)
Como instanciar uma expressao como 3 + 4 + 5 - 2?
exp1 :: Exp
exp1 = Add (Val 3) (Add (Val 4) (Sub (Val 5) (Val (-2))))
data Exp = Val Int
| Add Exp Exp
| Sub Exp Exp
O tipo Exp segue uma estrutura de arvore
(um pouco
exp1 :: Exp
data Exp = Val Int
| Add Exp Exp
| Sub Exp Exp
exp1 :: Exp
data Exp = Val Int
| Add Exp Exp
| Sub Exp Exp
exp1 :: Exp
data Exp = Val Int
| Add Exp Exp
| Sub Exp Exp
exp1 :: Exp
. . . e mais interessante, como avaliar expressoes?
eval :: Exp -> Int
eval (Val Int) = Int
eval (Add l r) = (eval l) + (eval r)
eval (Sub l r) = (eval l) - (eval r)
Na proxima aula construiremos um parser para expressoes
aritmeticas.
eval :: Exp -> Int
aritmeticas.
eval :: Exp -> Int
aritmeticas.
Type Classes
Polimorsmo parametrizado
Algumas funcoes sao aplicadas de forma generalizada,
independente do tipo.
id :: a -> a
id x = x
head :: [a] -> a
head [] = error "..."
head (x:xs) = x
length :: [a] -> Integer
length [] = 0
length (x:xs) = 1 + length xs
Por outro lado, em algumas situa coes precisamos denir que
uma funcao e aplicada a qualquer tipo t, desde que os valores
do tipo t satisfacam alguma propriedade.
Exemplos (1/3)
A fun cao elem verica se um valor e elemento de uma lista, usando
o teste de igualdade.
elem e [] = False
elem e (x:xs) = if (x == e) then True else elem e xs
Qual o tipo da fun cao elem?
elem :: (Eq t) => t -> [t] -> Bool
Exemplos (1/3)
A fun cao elem verica se um valor e elemento de uma lista, usando
o teste de igualdade.
elem e [] = False
elem e (x:xs) = if (x == e) then True else elem e xs
Qual o tipo da fun cao elem?
elem :: (Eq t) => t -> [t] -> Bool
Onde Eq e uma type class que dene os operadores (==) e
(/=). Lemos que a funcao elem recebe um argumento de um
tipo t qualquer, uma lista tambem do tipo t, e retorna um
booleano
desde que o tipo t seja uma instancia da classe
Eq.
class Eq a where
(==), (/=) :: a -> a -> Bool
x /= y = not (x == y)
x == y = not (x /= y)
booleano desde que o tipo t seja uma instancia da classe
Eq.
class Eq a where
(==), (/=) :: a -> a -> Bool
x /= y = not (x == y)
x == y = not (x /= y)
booleano desde que o tipo t seja uma instancia da classe
Eq.
class Eq a where
(==), (/=) :: a -> a -> Bool
x /= y = not (x == y)
x == y = not (x /= y)
Exemplos (2/3)
A funcao sum adiciona os valores de uma lista usando o operador
(+), independente da lista ser de inteiros, double, . . . .
sum = foldr (+) 0
-- o mesmo que:
-- sum [] = 0
-- sum (x:xs) = x + sum xs
Qual o tipo da fun cao sum?
sum :: (Num t) => [t] -> t
Exemplos (2/3)
sum = foldr (+) 0
-- o mesmo que:
-- sum [] = 0
sum :: (Num t) => [t] -> t
Exemplos (2/3)
sum = foldr (+) 0
-- o mesmo que:
-- sum [] = 0
sum :: (Num t) => [t] -> t
Exemplos (2/3)
sum = foldr (+) 0
-- o mesmo que:
-- sum [] = 0
sum :: (Num t) => [t] -> t
Onde Num e uma type class que dene os operadores (+),
(-), (*), . . . . Lemos que a funcao sum recebe uma lista de um
tipo t qualquer, e retorna um valor do tipo t, desde que o
tipo t seja uma instancia da classe Num.
class (Eq a, Show a) => Num a where
(+), (-), (*) :: a -> a -> a
negate :: a -> a
abs, signum :: a -> a
fromInteger :: Integer -> a
Onde Num e uma type class que dene os operadores (+),
(-), (*), . . . . Lemos que a funcao sum recebe uma lista de um
tipo t qualquer, e retorna um valor do tipo t, desde que o
tipo t seja uma instancia da classe Num.
class (Eq a, Show a) => Num a where
(+), (-), (*) :: a -> a -> a
negate :: a -> a
abs, signum :: a -> a
fromInteger :: Integer -> a
Exemplos (3/3)
A funcao qsort ordena os valores de uma lista, usando os
operadores (<=) e (>=), independente da lista ser de strings,
inteiros, double, . . .
qsort [] = []
qsort (x:xs) = qsort ys ++ [x] ++ qsort zs
where
ys = [y | y <- xs , y <= x]
zs = [z | z <- xs , z >= x]
Qual o tipo da fun cao qsort?
qsort :: (Ord t) => [t] -> [t]
Exemplos (3/3)
A funcao qsort ordena os valores de uma lista, usando os
operadores (<=) e (>=), independente da lista ser de strings,
inteiros, double, . . .
qsort [] = []
qsort (x:xs) = qsort ys ++ [x] ++ qsort zs
where
ys = [y | y <- xs , y <= x]
zs = [z | z <- xs , z >= x]
Qual o tipo da fun cao qsort?
qsort :: (Ord t) => [t] -> [t]
Onde Ord e uma type class que dene os operadores (<),
(>), (<=), (>=), . . . . Lemos que a fun cao qsort recebe e
retorna uma lista de um tipo t qualquer, desde que o tipo t
seja uma instancia da classe Ord.
class (Eq a) => Ord a where
compare :: a -> a -> Ordering
(<), (<=), (>=), (>) :: a -> a -> Bool
max, min :: a -> a -> a
compare x y | x == y = EQ
| x <= y = LT
| otherwise = GT
x <= y = compare x y /= GT
x < y = compare x y == LT
x >= y = compare x y /= LT
x > y = compare x y == GT
max x y | x <= y = y
| otherwise = x
min x y | x <= y = x
| otherwise = y
Classes pre-denidas
Como simplicar expressoes?
Se duas expressoes exp1 e exp2 forem iguais, podemos avaliar
uma das expressoes (exp1) e reusar o resultado na avaliacao
de exp2.
Precisamos denir o data type Exp como uma instancia de Eq.
instance Eq Exp where
(==) (Val x) (Val y) = x == y
(==) (Add e1 e2) (Add e3 e4) = (e1==e3 && e2==e4) || (e1==e4 && e2==e3)
(==) (Sub e1 e2) (Sub e3 e4) = (e1==e3 && e2==e4) || (e1==e4 && e2==e3)
Algumas instancias de classses podem ser derivadas
automaticamente. Nem sempre optamos por essa facilidade.
de exp2.
(==) (Val x) (Val y) = x == y
de exp2.
(==) (Val x) (Val y) = x == y
automaticamente.
Nem sempre optamos por essa facilidade.
de exp2.
(==) (Val x) (Val y) = x == y
Conforme mencionado, podemos ter diferentes tipos de arvores
Binary e Rose Trees
-- arvores binarias
data BTree a = Leaf
| BNode BTree a BTree
-- rose tree, com um numero arbitrario de
-- subarvores
data RoseTree a = RNode a [RoseTree]
Abstract syntax trees
-- arvores sintaticas
-- nesse exemplo, para expressoes aritmeticas
data Exp = Val Int
| Add Exp Exp
| Sub Exp Exp
Por outro lado, existem func oes que gostaramos de
aplicar a qualquer tipo de arvore
vericar a profundidade de uma arvore
recuperar as subarvores
aplicar uma fun cao a cada no da arvore
reduzir uma arvore a um valor especco
. . .
Por outro lado, existem func oes que gostaramos de
aplicar a qualquer tipo de arvore
vericar a profundidade de uma arvore
recuperar as subarvores
aplicar uma fun cao a cada no da arvore
reduzir uma arvore a um valor especco
. . .
Como generalizar essas operac oes?
Um unico data type com diferentes construtores
pouco extensvel
novos tipos de arvores nao poderiam ser denidos em outros
modulos
Extensibilidade pode ser alcancada criando uma type class
para generalizar arvores.
pouco extensvel
modulos
pouco extensvel
modulos
pouco extensvel
modulos
Denindo uma type classe para arvores
Inicialmente, com uma unica (e util) funcionalidade para recuperar
a lista de subarvores de uma arvore qualquer.
class Show t => Tree t where
subtrees :: t -> [t]
Instancias da classe Tree
instance (Show a) => Tree (BTree a) where
subtrees Leaf = []
subtrees (BNode l _ r) = [l, r]
instance (Show a) => Tree (RoseTree a) where
subtrees (RNode _ st) = st
instance Tree Exp where
subtrees (Val i) = []
subtrees (Add l r) = [l, r]
subtrees (Sub l r) = [l, r]
Uma biblioteca de func oes uteis pode ser construda
reusando subtrees
calcular o n umero de nos em uma arvore
calcular a profundidade de uma arvore
realizar busca em profundidade e largura
Tarefa para os alunos em sala: calcular o n umero de
n os em uma arvore usando a denicao de subtrees
reusando subtrees
reusando subtrees

Types Haskell

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Types Haskell

Enviado por

Direitos autorais:

Formatos disponíveis

Declaracao de tipos e classes

Arvores sao frequentemente usadas para representar

Arvores sao frequentemente usadas para representar

Você também pode gostar