Aula 19

se f é uma função binaria, então `f` é uma versão infixa dessa função

max 4 19
4 `max` 19

elem _ [] = False
elem x (a:as) 
   | x == a = True 
   | otherwise = elem a as 

3 `elem` [4,5,6,7]

:t no modo interativo imprime o tipo da expressão

:t 6
:t True
:t head

Tipos básicos

• Int - inteiro de maquina
• Integer - inteiro sem limites
• Float
• Double
• Bool
• Char

Tipos compostos

• [a] : lista de a
• a -> b : função que recebe a e devolve b
• (a,b) : tupla de a e b
• os tipos internos nao precisam estar definidos ou ser tipos basicos

:t head

:t max

• a -> b -> c é uma funcao que recebe a e b e retorna c (1a versao OK).
• na verdade é para ser interpretado como a -> (b -> c) uma funcao que recebe a e retorna uma funcao que espera receber b para retornar c

Todas as funções em Haskell são (podem ser vistas como) funções de 1 só argumento

max 31 10  ==>  (max 31)         10
                (funcao a -> a)  10   => a

ii = max 31

:t ii

ii 10

Hierarquia de tipos e restrições

:t head
head :: [a] -> a

:t max
max :: Ord a => a -> a -> a

:t (+)
(+) :: Num a => a -> a -> a

• Ord tipos para os quais < e > estão definidos
• Num tipos para os quais +,- (* /) estão definidos
• Eq tipos com igualdade

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

:t conta

ultimo :: [a] -> a
ultimo [x] = x
ultimo (x:xs) = ultimo xs

Especificar o tipo pode ajudar a achar erros

reverte [] = []
reverte (x:xs) = reverte xs ++ x

main = print $ reverte [1,2,3]

reverte :: [a] -> [a]
reverte [] = []
reverte (x:xs) = reverte xs ++ x

main = print $ reverte [1,2,3]

take 0 _ = []
take n (x:xs) = x : take (n-1) xs

take 5 [20..100]

take 5 [20..]

take 5 $ drop 10 [100..]

• listas não são criadas por inteiro
• listas são um um "objeto" que é capaz de computar o próximo elemento da lista thunk
• take n (x:xs) pega o próximo elemento s e xs continua sendo esse objeto
• take (n-1) xs é um novo thunk
• essas pilhas de promessas de computação só é executada em certas condições. Print no modo interativo ou compilado é uma delas

Se possível faça as 2 versões (com e sem acumulador) de cada um desses exercicios SEM USAR as funcoes pre-definidas do haskell a nao ser ++ que é a concatenacao de listas

• maior elemento de uma lista
• ultimo elemento de uma lista

ultimo [x] = x
ultimo (_:xs) = ultimo xs

• lista sem o ultimo elemento
• apenas os elementos nas posicoes 1, 3. 5 etc da lista

posimpar [] = []
posimpar [a] = [a]
posimpar (a:b:resto) = a : posimpar resto

• apenas os elementos positivos de uma lista de numeros

sopos l = [x | x<-l, x>0]

• a soma dos elementos positivos de uma lista de numeros

• retorna True se a lista estiver ordenada crescentemente
• shift right (1 2 3 4) -> (4 1 2 3)
• shift left (1 2 3 4) -> (2 3 4 1)
• revere uma lista (1 2 3 4) -> (4 3 2 1)
• conta quantas vezes um item aparece numa lista (conta item lista) (0 caso nao apareça)
• em que posição um item aparece numa lista (-1 se nao aparece)
• (remove item list) retorna a lista sem o item - em todas as vezes que ele aparece
• (replace item novo lista) retorna lista onde todos os items foram trocado por novo