Programação Funcional Utilizando haskell

1. Programação Funcional
em Haskell
7a Reunião —IO, Algumas Bibliotecas

2. Conteúdo e objetivos
 Introdução à programação funcional usando Haskell
 Objetivos de aprendizagem
 Introdução a Programas Interativos;
 Algumas Bibliotecas do Haskell;

3. Programas Interativos
Até agora apenas escrevemos programas que efetuam
computação pura, i.e., transformações funcionais entre valores.
Vamos agora ver como escrever programas interativos:
• lêm informação do teclado, ficheiros, etc.;
• escrevem no terminal ou em ficheiros;
• . . .

4. Ações de I/O
Introduzimos um novo tipo IO ()
Encadear ações
Podemos combinar duas ações de I/O usando o operador de
sequênciação:
Exemplos:
putChar ‘X’ :: IO () -- imprime um ’X’
putChar ‘Z’ :: IO () -- imprime um ’Y’
putChar :: Char -> IO () -- imprimir um carater
(>>) :: IO () -> IO () -> IO ()
Exemplos:
(putChar ‘X' >> putChar ‘Z') :: IO () -- imprimir “XZ"
(putChar ‘Z' >> putChar ‘X') :: IO () -- imprimir “ZX"
Note que >> é associativo mas não é comutativo!

5. Encadear ações (cont.)
Em alternativa podemos usando a notação-do:
Encadear ações
Podemos omitir os sinais de pontuação usando a indentação:
putChar ‘C' >> putChar ‘R' >> putChar ‘S'
Equivale à:
do {putChar ‘C'; putChar ‘R'; putChar ‘S'}
do putChar ‘C'
putChar 'R‘
putChar ‘I‘
putChar ‘S‘

6. Execução
Para efetuar as ações de I/O definimos um valor main no
módulo Main.
Encadear ações
Podemos omitir os sinais de pontuação usando a indentação:
module Main where
main = do putChar 'A'
putChar 'B‘
Compilar e executar:
$ ghc Main.hs -o prog
$ ./prog
AB$
ou
$ ghc --make Main.hs prog
$ ./prog

7. Execução (cont).
Também podemos efetuar ações IO diretamente no ghci:
Prelude> putChar 'A' >> putChar 'B’ >> putChar ‘n’
AB
Prelude>

8. Ações IO pré-definidas
getChar :: IO Char -- ler um caracter
getLine :: IO String -- ler uma linha
getContents :: IO String -- ler toda a entrada padrão
putChar :: Char -> IO () -- escrever um caracter
putStr :: String -> IO () -- escrever uma linha de texto
putStrLn :: String -> IO () -- idem com mudança de linha
print :: Show a => a -> IO () -- imprimir um valor
return :: a -> IO a -- ação vazia

9. Algumas Bibliotecas
Data.List operações sobre listas
Data.Set conjuntos finitos
Data.Map tabelas de associação
Data.Time funções de relógio e tempo
Network.HTTP protocolo de rede HTTP

10. Data.List
Mais funções sobre listas (para além do Prelúdio):
insert :: Ord a => a -> [a] -> [a]
delete :: Eq a => a -> [a] -> [a]
nub :: Eq a => [a] -> [a]
union :: Eq a => [a] -> [a] -> [a]
intersect :: Eq a => [a] -> [a] -> [a]
sort :: Ord a => [a] -> [a]
find :: (a -> Bool) -> [a] -> Maybe a
. . .muitas mais omitidas.

11. Exemplos Data.List (cont.)
> import Data.Char
> import Data.List
> insert 3 [1,2,5,7] -- lista ordenada
[1,2,3,5,7]
> nub "banana"
"ban"
> delete 'a' "banana"
"bnana"
> find isUpper "banana"
Nothing
> find (>'b') "banana"
Just 'n'

12. Data.Set
data Set a
empty :: Set a
fromList :: Ord a => [a] -> Set a
insert, delete :: Ord a => a -> Set a -> Set a
member :: Ord a => a -> Set a -> Bool
size :: Set a -> Int
union, intersection, difference :: Ord a =>
Set a -> Set a -> Set a
. . .muitas outras funções omitidas.

13. Exemplos Data.Set (cont.)
> import Data.Set
> let a = fromList [1,3..20]
> let b = fromList [1,5..20]
> intersection a b
fromList [1,5,9,13,17]
> difference a b
fromList [3,7,11,15,19]
> member 15 (difference a b)
True
> size (difference a b)
5

14. Network.HTTP & Data.Time
-- obter a hora e data atual
import Data.Time
main = do t <- getCurrentTime
putStrLn ("Data e hora atual: " ++ show t)
-- buscar uma página HTML como texto
import Network.HTTP
main = do r <- simpleHTTP (getRequest url)
html <- getResponseBody r
putStrLn html
where url = "http://www.haskell.org"

15. Bibliografia
Haskell - Uma abordagem prática. Cláudio César de Sá e
Márcio Ferreira da Silva. Novatec, 2006.
http://haskell.tailorfontela.com.br/
http://www.dcc.fc.up.pt/
http://www.haskell.org/hoogle/

16. Agradecimentos
Ao Prof°- Ricardo Reis e a todos os participantes do projeto
haskell ufc.