Operações com lista em Haskell

Criando um intervalo com número de 1 até 10
Prelude> [1..10]
[1,2,3,4,5,6,7,8,9,10]

Concatenando uma lista
Prelude> [1,2,3] ++ [4,5,6]
[1,2,3,4,5,6]

Tipo da função concatena
Prelude> :type (++)
(++) :: [a] -> [a] -> [a]

Construção de listas
Prelude> 1:2:3:[]
[1,2,3]
Tipo da função de construção de lista
Prelude> :type (:)
(:) :: a -> [a] -> [a]

Cabeça de uma lista
Prelude> head [1,2,3,4]
1

Prelude> :type head
head :: [a] -> a

Cauda de uma lista

Prelude> tail [1,2,3,4]
[2,3,4]

Último de uma lista
Prelude> last [1,2,3,4]
4

Inicio de uma lista
Prelude> init [1,2,3,4]
[1,2,3]

Inverter uma lista
Prelude> reverse [1,2,3,4]
[4,3,2,1]

Lista Vazia
Prelude> null []
True
Prelude> null [1,2,3]
False

Tamanho de uma lista
Prelude> length [1,2,3,4]
4


Acesso indexado de uma lista

Prelude> [1,2,3,4] !! 0
1
Prelude> :type (!!)
(!!) :: [a] -> Int -> a

Funções anônimas 

Prelude> (\x->x*x) 2
4

Funções de alta ordem

map: recebe uma função e uma lista devolve uma lista.
map f [x0,x1,..,xn] = [f x0,f x1,...,f xn]
Prelude> :type map
map :: (a -> b) -> [a] -> [b]
Prelude> map (\x->x*x) [1..10]
[1,4,9,16,25,36,49,64,81,100]

filter: recebe uma função que recebe uma valor devolvendo um booleano e uma lista devolvendo uma lista com os valores que retornam True pela função.
Prelude> :type filter
filter :: (a -> Bool) -> [a] -> [a]
Prelude> filter (\x->x>10) (map (\x->x*x) [1..10] )
[16,25,36,49,64,81,100]

Função de redução de listas
Prelude> :type foldl
foldl :: (a -> b -> a) -> a -> [b] -> a
Prelude> foldl (+) 0 [1..10]
55
Prelude> sum [1..10]
55
Prelude> product [1..10]
3628800
Prelude> maximum [1..10]
10
Prelude> minimum [1..10]
1

Funções zip e unzip
Função zip: combina duas listas produzindo uma lista de pares ordenados

Prelude> :type zip
zip :: [a] -> [b] -> [(a, b)]
Prelude> zip [1,2,3] [4,5,6]
[(1,4),(2,5),(3,6)]
Função unzip recebe uma lista de pares ordenados produzindo um par ordenado de listas
Prelude> :type unzip
unzip :: [(a, b)] -> ([a], [b])
Prelude> unzip [(1,2),(3,4),(5,6)]
([1,3,5],[2,4,6])
Função zipWith recebe uma função que recebe dois parâmetros e duas listas produzindo uma lista.
Prelude> :type zipWith
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
Prelude> zipWith (+) [1,2,3] [4,5,6]
[5,7,9]


Avaliação Preguiçosa

Prelude> take 5 [1..10]
[1,2,3,4,5]
Prelude> let fibs = 0:1:zipWith (+) fibs (tail fibs)
Prelude> take 5 fibs
[0,1,1,2,3]
Prelude> take 15 fibs
[0,1,1,2,3,5,8,13,21,34,55,89,144,233,377]
Prelude> fibs !! 100
354224848179261915075


Prelude> let lista = iterate (\x->2*x) 2
Prelude> take 10 lista
[2,4,8,16,32,64,128,256,512,1024]
Prelude> take 20 lista
[2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,
524288,1048576]
Prelude> let lista2 = repeat 5
Prelude> take 10 lista2
[5,5,5,5,5,5,5,5,5,5]
Prelude> let lista3 = cycle [1..5]
Prelude> take 10 lista3
[1,2,3,4,5,1,2,3,4,5]