Haskell

Introdução a Linguagem
de Programação Haskell
Bruno Rafael
Emanuel Franco
Iorgama Porcely
Jessyka Oliveira

27 de Novembro

Tópicos

 Introdução a Haskell
 Tipos de dados
 Operadores
 Criando funções
 Recursão
 Pattern Matching
 Guards
 Listas
 Tuplas

O que é Haskell?

 Linguagem de programação puramente
funcional.

 Variáveis imutáveis;

 Expressões em formas de funções, sem
efeitos colaterais, ou seja, a função ira
somente calcular algo e devolve-lo como
resultado.

O que é Haskell?

 Inicialmenteessa forma pode ser visto como
uma limitação, porém:

 Quando uma função é chamada duas vezes
com os mesmos parâmetros, é garantido o
retorno do mesmo resultado. Isso se chama
transparência referencial.

Transparência referencial

 Permite
que o compilador raciocine sobre o
comportamento do programa;

 Permiteque você deduza
facilmente (e até mesmo prove)
que uma função está correta;

 Permitea construção de funções mais
complexas juntando diversas funções
simples

Haskell é preguiçoso

 Não irá executar funções e calcular as coisas
antes que ele seja realmente obrigado a lhe
mostrar um resultado.

 Istopermite simplificar
coisas como estruturas de
dados infinitas.

Exemplo

 Temos a seguinte lista de números imutável:

 xs = [1,2,3,4,5,6,7,8]

 Função DoubleMe (Multiplica cada elemento
por 2 e retorna uma nova lista)

 Queremos multiplicar nossa lista por 8.

Na linguagem imperativa

 Fazendo:
doubleMe (doubleMe (doubleMe (xs )))

 Provavelmente iria passar uma vez pela lista,
fazer uma cópia e retornar. Em seguida, ele
iria passar por mais duas vezes e retornar o
resultado.

Na linguagem preguiçosa

 Fazendo:
doubleMe (doubleMe (doubleMe (xs )))

A função será executada
para o primeiro elemento
da lista, seguido dos
elementos seguintes.
Assim a lista é percorrida somente uma vez.

Haskell é estaticamente tipada

O compilador saberá no código o que é um
número, o que é uma string e assim por
diante.

 Uma série de possíveis erros poderão ser
capturados em tempo de compilação.

 Ex.: Tentando adicionar um número a uma
string, o compilador ira se queixar com você.

Inferência de Tipo

 Não é necessário explicitamente identificar
cada pedaço de código com um tipo;
 O sistema de tipos inteligente do Haskell
descobrirá muito sobre ele.
Ex.: Tendo a = 5 + 4, não é necessário dizer
que a é um número, pois já será identificado.

Elegante e Conciso

 Utiliza
uma série de conceitos de alto nível;
 Programas Haskell são normalmente mais
curtos do que os seus equivalentes
imperativos;
 Programas mais curtos são mais fáceis de
se manter e têm menos bugs.

Feito por caras realmente
inteligentes
 O trabalho sobre Haskell
começou em 1987 quando
uma comissão de
pesquisadores se reuniu
para projetar uma linguagem
matadora. Em 2003, o Relatório
Haskell foi publicado já com
uma versão estável da
linguagem.

O que preciso para começar?

 Interpretador HUGS
http://cvs.haskell.org/Hugs/pages/downloadin
g.htm
 Compilador GHC
http://www.haskell.org/ghc/download.html

HUGS – Primeiros comandos

 :quit - Sai do Hugs

 :? - Exibe a ajuda do Hugs

 :load <caminho_do_arquivo> - Carrega um
arquivo para o Hugs

 :reload - Recarrega o último arquivo
carregado

Operações

 Pode-se utilizar todos operadores comuns
em uma só linha e todas suas regras usuais
precedentes serão obedecidas.

Operações

 Podemos utilizar parênteses para declarar
de forma explicita a operação precedente ou
para mudá-la

Operações

 Sevocê quiser obter números negativos,
sempre tenha a operação determinada por
parênteses.

Fazendo 5 * -3 o GHCI irá gritar com você;

Fazendo 5 * (-3) isto irá funcionar
perfeitamente

Operações Booleanas

 Onde && refere-se a expressão
booleana and, ||refere-se a expressão
booleana or. not faz a negação de
um True ou de um False.

Testes de igualdades

 Vejamos alguns testes com operadores de
igualdade:

Operadores para inteiros

 Além dos operadores convencionais temos:

^ : para cálculos de Potência.

ghci> 2 ^ 4
16
ghci> 4 ^ 4
256 Q

Funções para Inteiros

 div : divisão de números
ghci> div 4 2
2

 mod: resto da divisão
ghci> mod 10 3
1


 succ : retorna sucessor

ghci> succ 8
9

 negate: muda sinal do número

ghci> negate 10
-10


 mim : retorna menor valor
ghci> mim 9 10
9

 max: retorna maior valor
ghci> max 100 101
101


 Fuções podem ser escritas como
operadores, e vice-versa:

ghci> 4 `div` 2
2

ghci> (+) 4 2
6


 As funções tem precedencia sobre as
operações, como podemos ver abaixo:

 As duas expressões são equivalentes.

Tipos e Funções para Float

 Os mesmos dos inteiros, com mais alguns:

 ** : Exponenciação;

 cos, sin, tag: Coseno, Seno e Tangente;

 log: Logaritmo na base e;

 logBase: Logaritmo em base qualquer.

Tipos e Funções para Float

 sqrt: raiz quadrada;
ghci> sqrt 16
4.0

 pi: Constante pi;
ghci> 2 * pi
6.28318530717959

Fazendo sua própria função

 Vamos agora fazer nossa primeira função.
No editor de texto escreva:
doubleMe x = x + x

Salve como “baby.hs”.

Essa função retornará o dobro
do valor de entrada.

Fazendo sua própria função

 Indoao local onde o arquivo foi salvo
execute os seguintes passos:
ghci> :1 baby
[1 of 1] Compiling Main             ( baby.h
s, interpreted )
Ok, modules loaded: Main.

-- Função compilada, agora vamos
testar

ghci> doubleMe 9
18
ghci> doubleMe 8.3
16.6

Recursão

 Forma de definir funções que fazem
chamadas a si próprias.

Recursão

 Forma de definir funções que fazem
chamadas a si próprias.
 Regras:
– Ter condição de parada.
– Tornar o problema mais simples.

Recursão

 Fatorial:
- Condição de parada: fatorial 0 = 1.
- Ex: 3!
= 3 * 2!
= 2 * 1!
= 1 * 0!
= 0!

Recursão

 Fatorial:
- Condição de parada: fatorial 0 = 1.
- Ex: 3!
= 3 * 2!
= 2 * 1!
= 1 * 0!
= 0! = 1
Logo, 3 * ( 2 * ( 1 * 1)) .

Recursão

fatorial.hs

Terminal ghci.

Recursão

 Fibonacci:
- Condição Limite:
F(0) = 0.
F(1) = 1.
- F(n) = F(n – 1) + F(n - 2)

Recursão

 Fibonacci:
- EX: F(3)
F(3) = F(2) + F(1)
F(2) = F(1) + F(0)
F(1) = 1
F(0) = 0

Recursão

 Fibonacci:
- EX: F(3)
F(3) = F(2) + F(1)
F(2) = F(1) + F(0)
F(1) = 1
F(0) = 0

Logo, F(3) = F(1) + F(0) + F(1).

Recursão

fibonacci.hs

Terminal ghci

Pattern Matching

 Pesquisa por padrões de dados e, caso
obtenha sucesso, fazer algo com ele.

Pattern Matching

 Construção sintática do Haskell.

Pattern Matching

 Construção sintática do Haskell.
 Código:
– Simples.
– Conciso.
– Legível.

Pattern Matching

 Pode ser usado com:
– Números.
– Caracteres.
– Listas.
– Tuplas.

Pattern Matching

 Ex: sorte.hs

Terminal ghci

Pattern Matching

 Exercício:
Implementar a função sayMe.hs, que diz seu
parametro de 1 até 5 ou “não está entre 1 e 5”.

Pattern Matching

 Exercício:
Implementar uma função que diz se parametro de
1 até 5 ou “Não está entre 1 e 5”.
 Dicas:
1. SayMe :: (Num a) => a → String.
2. sayMe 1 = “Um!”.
(…)
3. sayMe x = “Não está entre 1 e 5”.

Pattern Matching

Resposta: sayMe.hs

Pattern Matching
 Ex2:
car.hs

Terminal ghci

Pattern Matching

Pattern Matching também pode falhar!

Guards

 Forma de testar se uma ou mais
propriedades são V. ou F.

Guards

 Forma de testar se uma ou mais
propriedades são V. ou F.
 Funcionam bem com Patterns.

Guards

 Ex:Função que repreende o usuário de uma
forma específica, dependendo do seu IMC.
– Imc <= 18,5: Considerado magro.
– Imc <= 25,0: Considerado saudável.
– Imc <= 30,0: Considerado gordo.

Guards

 Ex:
Melhorando o código: imc.hs

Guards

 Ex:
Melhorando o código:
Terminal ghci

Guards

 Exercício:

Implementar a função max.hs, que recebe
dois parâmetros e retorna o maior.

Guards

 Exercício:

max.hs

Maximum

 Recebeuma lista de coisas que podem ser
ordenadas e retorna a maior dela.

Maximum

 Recebeuma lista de coisas que podem ser
ordenadas e retorna a maior dela.

 Exemplo: Instâncias do Typeclass Ord.

Maximum

 Ex: Programa que recebe uma lista de
coisas e retorna a maior dela.

Maximum

 Ex:
maximo.hs

Maximum

 Exercício:
Implementar a Função somaLista.hs, para
somar os elementos de uma lista.

Maximum

 Exercício:
Implementar a Função somaLista.hs, para
somar os elementos de uma lista.
 Dicas:
1. sumList :: [Int] → Int.
2. Caso Base: sumList [] = 0.
3. Caso recursivo: sumList (a:as) = a + sumList
as.

Listas

 Listas são estruturas de dados homogêneas:
– Armazena vários elementos do MESMO tipo

– Lista de caracteres
 listaVogais = ['a','e','i','o','u']

– Lista de inteiros
 listaNumPar = [2,4,6,8]

Listas

 Listas são estruturas de dados homogêneas:
– Lista de caracteres

– Lista de inteiros

– Lista vazia

Listas

O que caracteriza uma lista?

utilizam colchetes

valores são separados por vírgulas

Listas

O Haskell irá reclamar da lista abaixo?

Listas

O Haskell irá reclamar da lista abaixo?

 Sim, porque não há apenas um tipo de dado
na lista!!

Listas

 Listas podem conter listas que contem listas

Operadores

 Pode-ser usado ainda >, <, >=, <=, ==, /=

E se as listas comparadas
são de tipos diferentes?

Strings – Um tipo especial

 String é uma lista de caracteres

 “hello” é o mesmo que ['h','e','l','l','o']

 String podem usar as mesmas funções de
listas

 Vamos conhecê-los?!

Operações com listas

 ++ → Unir duas listas:

:→ Acrescentar um elemento no início de
uma lista


 !! → Obter um elemento pelo seu índice

E se o índice for superior
ao tamanho da lista?


 head → retorna o primeiro elemento

 tail → retorna tudo, exceto o primeiro elemento

Cuidado para não
 last → retorna o último elemento Utilizá-los em
listas vazias!!
 init → retorna tudo, exceto o último elemento


 length → retorna o seu tamanho

 null → verifica se a lista é vazia

 reverse → reverte uma lista

 take→ retorna um
número desejados de
elementos da lista


 drop → similar ao take, mas
retira do início da lista

 maximum → retorna o maior elemento

 minimum → retorna o menor elemento

 sum → retorna a soma


 product → retorna o produto

 elem → verifica se o elemento pertence a lista

 replicate
→ repete o mesmo
elemento em um nova lista

Operações com listas - Ranges

E se você precisar de uma lista com todos os
números entre 1 e 10?

 Solução: [1,2,3,4,5,6,7,8,9,10]?

E se for entre 1 e 1000?

 ou 10000?


 Não!! Perda de tempo.

E se você precisar de uma lista com todos os
números entre 1 e 10? ou 1000?
ou 10000?

 Solução: Utilizamos os ranges!!


 São uma sequência aritmética de elementos
devidamente enumerados

 Números e caracteres podem ser enumerados.
Ex. 1, 2, 3,…, 100 | A, B, C, ..., Z


E se quisermos todos os números ímpares
entre 1 e 20? Ou se quisermos sempre ter o
terceiro número entre 1 e 20?

 Podemos definir etapas específicas!!

Tuplas

 Um jeito de armazenar muitos elementos em
um único lugar
 Não precisa ser homogênera

Tuplas

O que caracteriza uma tupla?

utilizam parênteses

valores são separados por vírgulas

Operadores

 Pode-ser usado ainda >, <, >=, <=, ==, /=

E se as tuplas
comparadas são de
tipos/tamanhos diferentes?

Operações com tuplas (par)

 fst → retorna seu primeiro componente

 snd → retorna seu segundo componente

Entradas e Saídas de dados

 Fornecer dados e receber dados são de
suma importância para que exista uma
interatividade maior entre usuário e máquina.


 Abram um editor de texto.

< main = putStr "hello, world" >

 Salvem em uma pasta com o nome “teste.hs”


 Compilar
– ghc -o teste teste.hs

 Executar
– ./teste


 putStr→ imprimi uma string sem pular linha
 putStrLn → imprimi uma string pulando uma
linha


main = do
putStrLn "Qual seu nome?"
name <- getLine
putStrLn ("Eu sou " ++ name)


import Data.Char
main = do
putStrLn "Qual é o seu primeiro nome?"
firstName <- getLine
putStrLn "Qual é o seu segundo nome?"
lastName <- getLine
let bigFirstName = map toUpper firstName
bigLastName = map toUpper lastName
putStrLn $ "Olá " ++ bigFirstName ++ " " ++
bigLastName


main = do
line <- getLine
if null line
then return ()
else do
putStrLn $ reverseWords line
main

reverseWords :: String -> String
reverseWords = unwords . map reverse . words


main = do
return ()
return "HAHAHA"
line <- getLine
return "BLAH BLAH BLAH"
return 4
putStrLn line


main = do
a <- return "Alô"
b <- return "Mundo!"
putStrLn $ a ++ " " ++ b


main = do
c <- getChar
if c /= ' '
then do
putChar c
main
else return ()


import Control.Monad

main = do
c <- getChar
when (c /= ' ') $ do
putChar c
main


main = do
a <- getLine
b <- getLine
c <- getLine
print [a,b,c]


main = do
rs <- sequence [getLine, getLine, getLine]
print rs


main = do
contents <- getContents
putStr (shortLinesOnly contents)

shortLinesOnly :: String -> String
shortLinesOnly input =
let allLines = lines input
shortLines = filter (line -> length line < 15) allLines
result = unlines shortLines
in result


import System.IO

main = do
contents <- readFile "/caminho/texto.txt"
putStr contents


import System.IO
import Data.Char

main = do
contents <- readFile "texto.txt"
writeFile "novotexto.txt" (map toUpper contents)


import System.IO

main = do
todoItem <- getLine
appendFile "novotexto2.txt" (todoItem ++ "n")

Referências Bibliográficas

 Aprender Haskell será um grande bem para
você!
http://haskell.tailorfontela.com.br/
 Programação Funcional com a linguagem
Haskell
http://www.cin.ufpe.br/~dclal/monitoria/duBoi
s.pdf

Haskell
Obrigada!
Perguntas?

Introdução a Linguagem
de Programação Haskell
Bruno Rafael
Emanuel Franco
Iorgama Porcely
Jessyka Oliveira

Haskell

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Haskell

Semelhante a Haskell (20)

Mais de Iorgama Porcely

Mais de Iorgama Porcely (6)

Último

Último (20)

Haskell