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

haskell online

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 + conta (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

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

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

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

_ casa com qq valor mas ele não pode ser usado.

Cuidado, não da para testar igualdade (só para []) no pattern matching. Isso 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) 

Proxima aula

• guards
• list comprehension

e

• let
• where

para definir variaveis e funcoes locais

Exercicios

Fazer os exercícios usando head tail : ++ e mod (modulo) 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

• posição do item na lista (0 se nao esta la, 1 se é o primeiro) **

• maior elemento de uma lista - FAZER p/ próxima aula - variáveis locais

• reverte uma lista - FAZER p/ próxima aula - recursão com acumulador

• 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 item da lista (1 vez so)

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 n (as primeiras n vezes)