Aula 2 - haskell super básico

livro texto capitulos: 2 (tipos, if, funções e listas) , 4 (pattern matching e guards) e 5 (recursão)

Funções

Define a função usando nomes, parametros e o corpo da função depois do =

Sintaxe:

Sem parenteses para separar o nome da função e seus argumentos na definição e na chamada.
Sem virgula separando os argumentos

duplica x = 2*x

duplica 56

soma a b = a + b

soma 2 (duplica 5)

if then else

O if define que expressão retornar, e tem sempre um else

maior a b = if a>b 
              then a 
              else b 

maior 5 8

if é uma expressão que retorna algo

(if x>100 then x else 2*x) + 78

listas

Sintaxe como em python mas só de dados do mesmo tipo

[4,5,3,2,3,7]

[] <-- lista vazia

Função head e tail para obter o 1o elemento e o resto da lista

head [14,5,16]
14

tail [14,5,16]
[5,16]

tail [1]
[]

tail []
Exception: Prelude.tail: empty list

Recursão - e apenas recursão

tamanho de uma lista

conta lista = if lista == [] 
           then 0
           else (1 + tamanho (tail lista))

quantas vezes x aparece na lista

vezes x lista = if lista == [] 
               then 0 
               else if head lista == x then 1 + vezes x (tail lista) 
                                   else vezes x (tail lista)

ou usando if como expressão

vezes x li  = if li == [] 
               then 0 
               else (if head li == x then 1 else 0) + vezes x (tail li)

Pattern matching

Funções podem ser escritas como um conjunto de regras que especificam os formatos dos argumentos.

(x:xs) quebra a lista no head que é colocado em x e no tail que é colocado no xs A lista vazia não pode ser quebrada dessa forma

[] é equivalente a testar se o valor recebido é a lista vazia.

tamanho [] = 0
tamanho (x:xs) = 1 + tamanho xs

vezes _ []  = 0
vezes x (a:as) = (if x==a then 1 else 0) + vezes x as

_ é uma variavel anonima que não pode ser usada (como em python)

Cuidado, não da para testar igualdade entre valores no pattern matching. O codigo abaixo nao dá certo:

---- ERRADO ERRADO -----
vezes _ [] = 0
vezes a (a:as) = 1 + vezes a as   <=== NAO FUNCIONA
vezes x (a:as) = vezes x as

remove o item x da lista (todas as instancias de x)

++ concatena 2 listas

remove _ [] = []
remove x (a:as) = if x == a
                     then remove x as 
                     else [a] ++ (remove x as)

o : pode ser usado para construir listas

remove _  [] = []
remove x (a:as) = if x == a
                     then remove x as 
                     else a:(remove x as)

o “:” tem baixa prioridade - é feito “depois”. O parenteses em torno de remove x (a:as)= é preciso pois sem ele o haskell entenderia (remove x a) : as = que é um erro de sintaxe.

Mas na ultima linha acima, a chamada da função tem maior prioridade. assim isso poderia ser escrito como

remove _  [] = []
remove x (a:as) = if x == a
                     then remove x as 
                     else a : remove x as

Mas use parenteses se vc estiver inseguro/insegura.

let in

let … in - define as variáveis e funções locais antes da chamada/expressão principal

maior [x] = x
maior (x:xs) = let
         mm = maior xs
     in if x>mm then x else mm

Proxima aula

guards
list comprehension

where

Exercicios

Fazer os exercícios usando head tail : ++ mod (modulo), let e pattern matching

Alguns são bem dificies de fazer usando apenas os conceitos da aula 1!

tamanho de uma lista
conta quantas vezes o item aparece na lista (0 se nenhuma)
soma dos elementos de uma lista
soma dos números pares de uma lista ( modulo = mod)
retorna o ultimo elemento de uma lista
existe item x na lista (True ou False)
dado n gera a lista de n a 1

range_rev n = if n==1
        then [1]
        else n:range_rev (n-1)
ou

range_rev' 1 = []
range_rev' n = n: range_rev (n-1)

posição do item na lista (0 se não esta lá, 1 se é o primeiro) **
reverte uma lista

-- tradicional fold right
rev1 [] = []
rev1 (x:xs) = rev1 xs ++ [x]


-- com acumulador do trabalho anterior fold left
rev lista = rev2 lista []
rev2 [] acc = acc
rev2 (x:xs) acc = rev2 xs (x:acc)

dado n gera a lista de 1 a n **
retorna a lista sem o ultimo elemento **
soma dos elementos nas posições pares da lista ( o primeiro elemento esta na posição 1)
intercala 2 listas (intercala1 e intercala2)

intercala1 [1,2,3] [4,5,6,7,8]
 ==> [1,4,2,5,3,6]

intercala2 [1,2,3] [4,5,6,7,8]
 ==>  [1,4,2,5,3,6,7,8]

a lista já esta ordenada? Retorna True ou False
shift para a direita

shiftr [1,2,3,4]
 ==> [4,1,2,3]

shiftr n lista (shift direita n vezes)
shift left
shift left n vezes
remove o item da lista (1 vez só)

remove1 4 [2,3,4,5,4,3,2,1]
==> [2,3,5,4,3,2,1]

remove item da lista (todas as vezes)

removeall 4 [2,3,4,5,4,3,2,1,4,4,3]
==> [2,3,5,3,2,1,3]

remove item da lista n (as primeiras n vezes)

removen 4 2 [2,3,4,5,4,3,2,1,4,4,3]
==> [2,3,5,3,2,1,4,4,3]

remove item da lista (a ultima vez que ele aparece) **
troca velho por novo na lista (1 so vez)

troca1 8 10 [2,4,6,8,11,12]
==> [2,4,6,10,11, 12]

troca velho por novo na lista (todas vezes)
troca velho por novo na lista (as primeiras n vezes)