Closures in Groovy

1. Overview

In this Introductory tutorial, we’ll explore the concept of closures in Groovy, a key feature of this dynamic and powerful JVM language.

Many other languages, including Javascript and Python, support the concept of closures. However, the characteristics and functioning of closures vary from language to language.

We’ll touch on key aspects of Groovy closures, showing examples of how they are used along the way.

2. What Is a Closure?

A closure is an anonymous block of code. In Groovy, it is an instance of the Closure class. Closures can take 0 or more parameters and always return a value.

Additionally, a closure may access surrounding variables outside its scope and use them — along with its local variables — during execution.

Furthermore, we can assign a closure to a variable or pass it as a parameter to a method. Therefore, a closure provides functionality for delayed execution.

3. Closure Declaration

A Groovy Closure contains parameters, the arrow ->, and the code to execute. Parameters are optional and, when provided, are comma-separated.

3.1. Basic Declaration

def printWelcome = {
    println "Welcome to Closures!"
}

Here, the closure printWelcome prints a statement when invoked. Now, let’s write a quick example of a unary closure:

def print = { name ->
    println name 
}

Here, the closure print takes one parameter — name — and prints it when invoked.

Since the definition of a closure looks similar to a method, let’s compare them:

def formatToLowerCase(name) {
    return name.toLowerCase()
}
def formatToLowerCaseClosure = { name ->
    return name.toLowerCase()
}

Here, the method and the corresponding closure behave similarly. However, there are subtle differences between a closure and a method, which we’ll discuss later in the Closures vs Methods section.

3.2. Execution

We can execute a closure in two ways — we can invoke it like it were any other method, or we can use the call method.

For instance, as a regular method:

print("Hello! Closure")
formatToLowerCaseClosure("Hello! Closure")

And executing with the call method:

print.call("Hello! Closure") 
formatToLowerCaseClosure.call("Hello! Closure")

4. Parameters

The parameters of Groovy closures are similar to those of regular methods.

4.1. Implicit Parameter

We can define a unary closure without a parameter because when parameters are not defined, Groovy assumes an implicit parameter named “it”:

def greet = {
    return "Hello! ${it}"
}
assert greet("Alex") == "Hello! Alex"

4.2. Multiple Parameters

Here’s a closure that takes two parameters and returns the result of multiplying them:

def multiply = { x, y -> 
    return x*y 
}
assert multiply(2, 4) == 8

4.3. Parameter Types

In the examples so far, there has been no type provided with our parameters. We can also set the type of closure parameters. For instance, let’s rewrite the multiply method to consider other operations:

def calculate = {int x, int y, String operation ->
    def result = 0    
    switch(operation) {
        case "ADD":
            result = x+y
            break
        case "SUB":
            result = x-y
            break
        case "MUL":
            result = x*y
            break
        case "DIV":
            result = x/y
            break
    }
    return result
}
assert calculate(12, 4, "ADD") == 16
assert calculate(43, 8, "DIV") == 5.375

4.4. Varargs

We can declare a variable number of arguments in closures, similar to regular methods. For example:

def addAll = { int... args ->
    return args.sum()
}
assert addAll(12, 10, 14) == 36

5. A Closure as an Argument

We can pass a Closure as an argument to a regular Groovy method. This allows the method to call our closure to complete its task, allowing us to customize its behavior.

Let’s discuss a simple use-case: the calculation of the volume of regular figures.

In this example, the volume is defined as area multiplied by height. However, calculation of area can vary for different shapes.

Therefore, we’ll write the volume method, which takes a closure areaCalculator as an argument, and we’ll pass the implementation of the area calculation during invocation:

def volume(Closure areaCalculator, int... dimensions) {
    if(dimensions.size() == 3) {
        return areaCalculator(dimensions[0], dimensions[1]) * dimensions[2]
    } else if(dimensions.size() == 2) {
        return areaCalculator(dimensions[0]) * dimensions[1]
    } else if(dimensions.size() == 1) {
        return areaCalculator(dimensions[0]) * dimensions[0]
    }    
}
assert volume({ l, b -> return l*b }, 12, 6, 10) == 720

Let’s find a volume of a cone using the same method:

assert volume({ radius -> return Math.PI*radius*radius/3 }, 5, 10) == Math.PI * 250/3

6. Nested Closures

We can declare and invoke closures inside a closure.

For instance, let’s add a logging ability to the already discussed calculate closure:

def calculate = {int x, int y, String operation ->
        
    def log = {
        println "Performing $it"
    }
        
    def result = 0    
    switch(operation) {
        case "ADD":
            log("Addition")
            result = x+y
            break
        case "SUB":
            log("Subtraction")
            result = x-y
            break
        case "MUL":
            log("Multiplication")
            result = x*y
            break
        case "DIV":
            log("Division")
            result = x/y
            break
    }
    return result
}

7. Lazy Evaluation of Strings

Groovy Strings are usually evaluated and interpolated at the time of creation. For instance:

def name = "Samwell"
def welcomeMsg = "Welcome! $name"
        
assert welcomeMsg == "Welcome! Samwell"

Even if we modify the value of the name variable, the welcomeMsg is not going to change:

name = "Tarly"
assert welcomeMsg != "Welcome! Tarly"

Closure interpolation allows us to provide lazy evaluation of Strings, recalculated from the current values around them. For example:

def fullName = "Tarly Samson"
def greetStr = "Hello! ${-> fullName}"
        
assert greetStr == "Hello! Tarly Samson"

Only this time, changing the variable affects the interpolated string’s value as well:

fullName = "Jon Smith"
assert greetStr == "Hello! Jon Smith"

8. Closures in Collections

Groovy Collections use closures in many of their APIs. For example, let’s define a list of items and print them using the unary closure each, which has an implicit parameter:

def list = [10, 11, 12, 13, 14, true, false, "BUNTHER"]

list.each {
    println it
}

assert [13, 14] == list.findAll{ it instanceof Integer && it >= 13 }

Often, based on some criterion, we may need to create a list from a map. For instance:

def map = [1:10, 2:30, 4:5]

assert [10, 60, 20] == map.collect{it.key * it.value}

9. Closures vs Methods

So far, we’ve seen the syntax, execution, and parameters of closures, which are fairly similar to methods. Let’s now compare closures with methods.

Unlike a regular Groovy method:

• We can pass a Closure as an argument to a method
• Unary closures can use the implicit it parameter
• We can assign a Closure to a variable and execute it later, either as a method or with call
• Groovy determines the return type of the closures at runtime
• We can declare and invoke closures inside a closure
• Closures always return a value

Hence, closures have benefits over regular methods and are a powerful feature of Groovy.

10. Conclusion

In this article, we’ve seen how to create closures in Groovy and explored how they are used.

Closures provide an effective way to inject functionality into objects and methods for delayed execution.