Aula 1 - haskell super básico

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

Funções são prefixas

sem parenteses para separar o nome da função e seus argumentos

duplica x = 2*x

duplica 56

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 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 - apenas recursão

tamanho de uma lista

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

quantas vezes x aparece na lista

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

Pattern matching

Funções podem ser escritas como um conjunto de regras que especificam os formatos dos argumentos. Em particular o formato [] é equivalente a dizer se o valor é a lista vazia.

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

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

(x:xs) quebra a lista no head que é colocado em x e no tail que esta em xs

- 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:

ERRDO ERRADO

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

remove o item x da lista

remove [] _ = []

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

o : pode ser usado para construir listas

remove [] _ = []

remove (a:as) it = if x = a
                     then remove as x
                     else a:remove as x

Proxima aula

guards
list comprehension

let
where

para definir variaveis e funcoes locais

Exercicios

Fazer os exercícios usando apenas head tail : ++ e % (modulo)

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

tamanho de uma lista
soma dos elementos de uma lista
soma dos números pares de uma lista ( modulo = %)
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)
conta quantas vezes o item aparece na lista (0 se nenhuma)
maior elemento de uma lista - FAZER p/ proxima aula - variáveis locais
reverte uma lista - FAZER p/ próxima aula - recursão com acumulados
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 posicao 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 ja esta ordenada?

shift right

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

shiftr n lista (shift right n vezes)
shift left
shift left n vezes

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