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.