This example shows 3 key features of functional programming: `map` `filter` and `map` function using haskell.

### Map

The function takes a function from a to b `(a -> b)` and a list of a `[a]` then product a list of b `[b]`.

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

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

``````

### Filter

The function takes a predicate function `(a -> Bool)` that return boolean (true/false) and a list `[a]` then produce a filtered list `[a]`.

``````filter :: (a -> Bool) -> [a] -> [a]
filter p xs = [ x | x <- xs, p x ]

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

``````

### Fold

The function takes a 2 parameters function `(a -> a -> a)`, an initial accumulator and a list then return an accumulate result.

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

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

``````