Functional programming languages provide a `map`

higher order function, which produces a new collection by applying the specified function on each element of the collection on which the map operation is invoked. Groovy uses `collect`

instead of `map`

.

Consider the following list of numbers.

```
def numbers = [1, 2, 3, 4]
```

Let's create a closure which takes a number and returns `number + 1`

```
def increment = { number ->
number + 1
}
```

If you are not familiar with the concept of pure functions, this post has the details.

Now we can apply this `increment`

mapping (transformation) on each of the element in the list `numbers`

.

An imperative solutions would look as follows

```
numbersIncrementedByOne = []
for(number in numbers) {
numbersIncrementedByOne << increment(number)
}
```

Similarly, let's create another closure to calculate the square of a number and compute the square of each number in the list of numbers.

```
def square = { number ->
number * number
}
squaresOfNumbers = []
for(number in numbers) {
squaresOfNumbers << square(number)
}
```

I hope you can recognise the pattern in applying `increment`

and `square`

. We can generalise this solution by creating a function that accepts a transformation closure and creates a new collection by applying the closure on each of the element. This function is readily available in Groovy with the name `collect`

. Let's refactor the above code to make use of `collect`

.

```
numbersIncrementedByOne = numbers.collect(increment) // returns [2, 3, 4, 5]
squaresOfNumbers = numbers.collect(square) // returns [1, 4, 9, 16]
```

You may want to take a look at the slides from my FunctionalConf talk for more examples.