data List a = Empty
            | Cons a (List a)

xs :: List Int
xs = Cons 1 (Cons 2 (Cons 3 Empty))

λ> :i []
data [] a = [] | a : [a]  -- Defined in ‘GHC.Types’

xs :: [Int]
xs = [1,2,3]              -- 1 : 2 : 3 : []

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

λ> map (+1) [1,2,3]
[2,3,4]

filter :: (a -> Bool) -> [a] -> [a]
filter _ []     = []
filter p (x:xs) | p x       = x : filter p xs
                | otherwise = filter p xs

λ> filter (>1) [1,2,3]
[2,3]

sum :: [Int] -> Int
sum []     = 0
sum (x:xs) = x + sum xs

λ> sum [1,2,3]
6

foldr :: (a -> b -> b) -> b -> [a] -> b
foldr f z []     = z
foldr f z (x:xs) = x `f` foldr f z xs

-- map f = foldr (\x xs -> f x : xs) []
--       = foldr (\x xs -> (:) (f x) xs) []
--       = foldr (\x -> (:) (f x)) []
--       = foldr (\x -> ((:) . f) x) []

map :: (a -> b) -> [a] -> [b]
map f = foldr ((:) . f) []

-- filter p = foldr (\x xs -> if p x then x : xs else xs) []

filter :: (a -> Bool) -> [a] -> [a]
filter p = foldr g []
  where g x xs | p x       = x : xs
               | otherwise = xs

sum :: [Int] -> Int
sum = foldr (+) 0

>> xs = [1,2,3,4]
>> [i * i for i in xs if i > 2]
[9, 16]

λ> xs =  [1,2,3,4]
λ> [ i * i | i <- xs, i > 2]
[9,16]