Complete o programa acima.

gr = Graph [ 0 , 1 , 2 , 3] [ ( 0 , 1 ) , ( 0 , 2 ) , ( 1 , 3 ) , ( 2 , 3 ) ]
s e a r c h A l l gr 0 3 : : Maybe [ I n t ] == J u s t [ 0 , 1 , 3 ]

o Funcional
Programaca
Lista de Exerccios 05

7. Vamos representar pontos de um plano cartesiano com duas coordernadas e regi

oes
es, usando os seguintes tipos:
desse plano como funco
data Ponto = P t F l o a t F l o a t
type Regiao = Ponto > Bool
Se r representa uma regi
ao do plano, ent
ao um ponto p est
a nessa regi
ao do plano
se r p e igual a True.

Prof. Wladimir Ara

ujo Tavares

es
(a) Defina
funco
retang::Ponto->Ponto->Regiao
e
circ::Ponto->Raio->Regiao tais que:
retang p q retorne (a regi
ao que representa) o ret
angulo tal que p e o ponto
` esquerda e mais baixo, e q o ponto mais a
` direta e mais alto.
mais a
circ p r retorne o crculo de raio r e centro p.
es.
Lembre-se: regi
oes s
ao representadas por funco

M
onadas Maybe
o log ::
1. A funca
negativos.

Floating a => a -> a n

ao est
a definida para n
umeros

> log 1000

6.907755278982137
> log (1000)
ERROR r u n t i m e e r r o r

es
(b) Defina
funco
uniao::Regiao->Regiao->Regiao,
interseccao::Regiao->Regiao->Regiao
e
complemento::Regiao->Regiao tais que p est
a em uniao r r se e
somente se p est
a na uniao das regi
oes r e r, e analogamente para
o e complemento.
intersecca

Defina uma vers

ao segura que evite runtime error usando Maybe.
s a f e L o g : : ( F l o a t i n g a , Ord a ) => a > Maybe a
safeLog x
| x > 0
=
| otherwise =
o sqrt :: Floating a => a -> a n
2. A funca
ao est
a definida para n
umeros
negativos. Defina uma vers
ao segura evitando erros usando Maybe.
o composta log sqrt(x) = log(sqrt(x)) usando
3. Faca a vers
ao segura da funca
o do.
com a notaca
s a f e L o g S q r t : : ( F l o a t i n g a , Ord a ) => a > Maybe a
s a f e L o g S q r t x = do {
}
o composta log sqrt(x) = log(sqrt(x)) usando
4. Faca a vers
ao segura da funca
o do usando >>=.
sem a notaca
s a f e L o g S q r t : : ( F l o a t i n g a , Ord a ) => a > Maybe a
safeLogSqrt x =
5. Considere o seguinte programa em Haskell:
type Person = S t r i n g
type Family = [ ( Person , Person , Person ) ]
p1 = B a r t Simpsons
p2 = L i s a Simpsons
p3 = Marge Simpsons
p4 = Homer Simpsons
p5 = Maggie Simpsons
p6 = Abraham Simpsons
p7 = Mona Simpsons
p8 = Ned F l a n d e r s
p9 = Maude F l a n d e r s
p10 = Rod F l a n d e r s
p11 = Todd F l a n d e r s
f = [ ( p4 , p3 , p1 ) ,
( p4 , p3 , p2 ) ,
( p4 , p3 , p5 ) ,
( p6 , p7 , p4 ) ,
( p8 , p9 , p10 ) ,
( p8 , p9 , p11 ) ]
o father :: Family -> Person -> Maybe Person que dado
(a) Faca a funca
uma pessoa retorne o pai da pessoa se existir na famlia f.
o mother :: Family -> Person -> Maybe Person que dado
(b) Faca a funca
uma pessoa retorne a m
ae da pessoa se existir na famlia f.
o paternalgrandfather :: Family -> Person -> Maybe
(c) Faca a funca
Person que dado uma pessoa retorne o av
o paterno da pessoa se existir
na famlia f.
o paternalgrandmother :: Family -> Person -> Maybe
(d) Faca a funca
Person que dado uma pessoa retorne a av
o paterno da pessoa se existir
na famlia f.
o bothGrandfathers :: Person -> Maybe (Person,
(e) Faca a funca
Person) que dado uma pessoa retorna os dois av
os paternos da pessoa se
existir na famlia f.
6. Considere o seguinte programa em Haskell:
data Graph = Graph [ I n t ] [ ( Int , I n t ) ]
s e a r c h : : Graph v e > I n t > I n t > Maybe [ I n t ]
s e a r c h g@( Graph v l e l ) s r c d s t
| s r c == d s t = J u s t [ s r c ]
| otherwise = s e a r c h e l
where s e a r c h [ ] =
search (( u , v ) : es )
| s r c == u =
case s e a r c h g v d s t of
J u s t p >
Nothing >
| otherwise =