*You must be the change you wish to see in the world.*"

-- Mahatma Gandhi

Working in an industry with large amounts of data and having a need to apply changes to this data, I often find myself needing to apply functions against members of a data set. In the world of functional programming this applying functions against a data set takes place on the island of higher order function on the beach known as mapping.

A mapping does exactly what we need to do when we want to apply a function against a data set, it takes each member of the data set and applies the function against it giving a resulting data set which has the results applied against it.

Here are a few simple examples:

### Case 0: Identity function

The identity function does nothing, it literally takes the input and passes it as the output, applying nothing against the input.

Both Haskell and F# have a built in function called id which is the identity function.

#### In Haskell (on codepad):

map id [1 .. 4]

=> [1,2,3,4]

#### In F# (on tryfsharp):

List.map id [1 .. 4];;

**val it : int list = [1; 2; 3; 4]**

### Case 1: Increment by 1

The "Hello World" for mapping (that actually does something) would be the increment by 1. The function would add 1 to each input yielding an output with values that are one greater than the input.

Both Haskell and F# allow for the applying of the addition operator (+) in a mapping,

#### In Haskell (on codepad):

map (+1) [1 .. 4]

=> [2,3,4,5]

#### In F# (on tryfsharp):

List.map ((+) 1) [1 .. 4];;

**val it : int list = [2; 3; 4; 5]**

### Case 2: Obtain first element of a tuple (or any complex data type)

One use that might not be obvious at first but is really useful is to map a certain part of a data set. Mapping a certain value of a data set can allow for other higher order functions to apply to element later on in a chain. Lets say you have a list of tuples and would like to get the first value of each one.

Both Haskell and F# have a first function which returns the first value in a tuple.

#### In Haskell (on codepad):

map fst [(1,2), (2,3), (3,5), (4,2)]

=> [1,2,3,4]

#### In F# (on tryfsharp):

List.map fst [(1,2); (2,3); (3,5); (4,2)];;

**val it : int list = [1; 2; 3; 4]**

There you have it a few simple examples of mapping in Haskell and F#.