Consider the following closures.

def increment = { number ->
    number + 1
}

def square = { number ->
    number * number
}

println increment(2) // 3
println square(2) // 4

If you are not familiar with closures, this article provides the necessary details.

Now suppose you want to calculate the square of a number and increment the result by 1, you could achieve it using a closure.

def incrementSquareByOne = { number ->
    increment(square(number))
}
println incrementSquareByOne(2) // 5

If you are an experienced developer, you will agree that this kind of chaining functions can be seen very often( unless you write long methods with a lot of duplicate code). Hence programming languages that support functional style provide a syntax for composing functions - which helps the developer to express the intention in a crisp and clear way. Function(closure) composition can be achieved in Groovy in the following way.

def incrementSquareByOne = increment << square
println incrementSquareByOne(2) // 5

That code was more readable than before, isn't it?

Closure incrementSquareByOne achieves the functionality of calling square and passing the result into increment. Note the direction of double arrow << specifies the order in which closures are invoked. If you wish, you could compose the closures from left to right as well.

def incrementSquareByOne = square >> increment
println incrementSquareByOne(2) // 5

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