Closures

A closure in Groovy is an open, anonymous, block of code that can take arguments, return a value and be assigned to a variable. Groovy uses closures to specify a code to be executed each time and adds the extra methods ( each, any, every, find, findAll, collect and so forth) to the collection classes to make them readily available.

See here for more information on Closures.

On this page:

Defining a closure

Simple declaration: The following example shows a simple closure syntax. When there is only one parameter passed into closure, its declaration is optional.

def log = ''
(1..10).each { counter -> log += counter }
log == "12345678910"

//it variable that needs no declaration
def log = ""
(1..10).each { log += it }
log == "12345678910"

Using assignments for declaration: A second way of declaring a closure is to directly assign it to a variable.

//Assigning a closure to a variable
Closure printer = { line -> println line }
printer instanceof Closure //returns true

//Empty closure
def emptyClosure = {}
emptyClosure instanceof Closure //returns true

//Assignment to the return value of a method
def Closure getPrinter() {
return{ line -> println line }
} 
getPrinter() instanceof Closure //returns true

Referring to methods as closures: Declaring a closure is to reuse something that is already declared a method. Groovy lets you reuse the code you already have in methods but as a closure.

//Method closure assignment statement
def c = reference.&someMethod

//Different implementations are called based on argument types
class MultiMethodSample {
 int mysteryMethod (String value) {
 return value.length()
 }
 int mysteryMethod (List list) {
 return list.size()
 }
 int mysteryMethod (int x, int y) {
 return x+y
 }
}
MultiMethodSample instance = new MultiMethodSample()
Closure multi = instance.&mysteryMethod

multi("Groovy in JMWE") == 14
multi(["a","Red",3.5]) == 3
multi(5,13) == 18

See below for an example that shows all of these ways of creating and using closures

Map map = ['a':1, 'b':2] 
//Closure passed as parameter directly
map.each{key, value -> 
  map[key] = value * 2  
}
map

//Assign a closure object to a variable and call it
doubler = {key, value -> 
  map[key] = value * 2  
}
map.each(doubler)

//Use of reference.&operator
def doubleMethod(entry){ 
 entry.value = entry.value * 2 
}
doubler = this.&doubleMethod 
map.each(doubler)

Calling a closure

A closure, as an anonymous block of code, can be called like any other method.

def code = { 1234 }
code() == 1234
code.call() == 1234

//int as a parameter
def numberIsOdd = { int i -> i%2 !=0 }
numberIsOdd(3) == true
numberIsOdd.call(4) == false

//Same closure with implicit parameter it
def numberIsOdd = { it%2 !=0 }
numberIsOdd(3) == true
numberIsOdd.call(4) == false

Parameters in a Closure

Parameters of closures follow the same principle as parameters of regular methods: an optional type, a name, an optional default value. They are separated with commas. It is possible for a closure to declare variable number of arguments. See the examples below.

//Two Explicit types arguments
def closure = {int a, int b ->
  a + b
}

//Two arguments
def closure = {a,b ->
  a + b
}

//Two arguments with one default
def closure = {int a, b = 5 ->
  a + b
}

//One Explicit type argument
def closure = {String name ->
  it.toUpperCase()
}

//One argument
def closure = {State ->
  it.toUpperCase()
}

//Varargs
def stringConcat = {String... it -> it.join('')}
stringConcat("abc","def","ghi")

def multiConcat = { int n, String... args ->                
    args.join('')*n
}
multiConcat(3,"John"," Carter ")

Using Closures

Some of the useful methods applicable to Closures are listed below. See here for more information.

//finds for the first match
def list = [1,2,30,34,42]
list.find{
	it > 30
}!=null

//finds all the matches
def list = [1,2,30,34,42]
def newList = list.findAll{
	it > 30
} == [34,42]

//Perform an operation on each
Map map = ['a':1, 'b':2] 
map.each{key, value -> 
  map[key] = value * 2  
}
map