"map" é uma função de ordem superior que recebe a função f que é aplicada ao longo da lista.

map :: (a -> b) -> [a] -> [b]
map f [] = []
map f (x:xs) = (f x) : (map f xs)

Exemplos :

triplos :: [Int] -> [Int]
triplos l = map (3*) l

triplos [1,2] = map (3*) [1,2]
 = 3*1 : map (3*) [2]
 = 3*1 : 3*2 : map (3*) []
 = 3*1 : 3*2 : []
 = 3:6:[] = [3,6]
-----------------------------------------------------------------------------------------
maiusculas :: String -> String
maiusculas xs = map toUpper xs

somapares :: [(Float,Float)] -> [Float]
somapares l = map aux l
    where aux (a,b) = a+b

Usando listas por compreensão, poderíamos definir a função "map" assim :

map f l = [ f x | x <- l ]

Consideremos as seguintes funções:

triplos :: [Int] -> [Int]
triplos [] = []
triplos (x:xs) = 3*x : triplos xs

Estas funções fazem coisas distintas entre si, mas a forma como operam é semelhante : aplicam uma transformação a cada elemento da lista de entrada.

maiusculas :: String -> String
maiusculas [] = []
maiusculas (x:xs) = toUpper x : maiusculas xs

Dizemos que estas funções têm um padrão de computação comum, e apenas diferem na função que é aplicada a cada elemento da lista.

somapares :: [(Float,Float)] -> [Float] 
somapares [] = []
somapares ((a,b):xs) = a+b : somapares xs

A função map do Prelude sintetiza este padrão de computação, abstraindo em relação à função que é aplicada aos elementos da lista.