Closures in Groovy

Analogy categoryAnalogies

Understanding Closures in Groovy

A closure in Groovy is a first-class block of code, represented by the groovy.lang.Closure class, that can be assigned to a variable, passed as a parameter, and invoked later, capturing variables from its enclosing scope even after that scope has finished executing. Unlike a plain Java lambda, a Groovy closure retains references to this, owner, and delegate, giving it flexible resolution rules for how it looks up properties and methods it doesn't define itself. This makes closures the foundation for both simple iteration helpers, like each and collect, and much more sophisticated builder-style DSLs.

🏏

Cricket analogy: A closure is like a specialist finisher such as MS Dhoni being told the required run rate and match situation before walking out - he closes over that context, target, overs left, field placements, and carries it with him to the crease long after the team meeting ended.

Defining and Invoking Closures

Closures are declared with curly braces: { params -> body }, and if no parameter list is given, an implicit single parameter named it is available inside the block. You call a closure using .call() or simply by adding parentheses after the variable name, and Groovy also lets you pass a closure as the last argument to a method outside its parentheses, which is how DSL-style syntax like 5.times { println it } becomes possible.

🏏

Cricket analogy: Calling a closure with .call() is like a bowler being handed the ball with no instructions and defaulting to bowling to the batter directly in front of them - the implicit it parameter is the default batter a closure targets when you don't name one.

groovy

def counter = 0
def increment = { counter++ }
5.times { increment() }
println counter                 // 5

// owner/delegate in action
def greetingBuilder = {
    delegate = [name: 'Ada']
    resolveStrategy = Closure.DELEGATE_FIRST
    "Hello, ${name}!"
}
println greetingBuilder()       // Hello, Ada!

Closures and Variable Scope (Closing Over State)

Because a closure closes over the variables in its defining scope rather than copying their values, changes made to a captured local variable inside the closure are visible outside it, and vice versa - this is what makes closures useful for accumulator patterns, counters, and callbacks that need to mutate shared state.

🏏

Cricket analogy: When a closure mutates a captured runsScored variable, it's like a scorer's tally that both the commentator and the scoreboard operator can update - a change either side makes is instantly visible to the other because they share the same tally, not separate copies.

Groovy closures freely capture and mutate local variables from their enclosing scope, unlike Java's lambdas which require captured variables to be effectively final. This is powerful for accumulator and callback patterns, but be careful when a closure is shared across threads or outlives the scope it captured - mutating shared state from multiple closures without synchronization can introduce race conditions just as it would with any shared mutable variable.

owner, delegate, and Resolve Strategy

Every closure exposes owner (the enclosing object where the closure was created), delegate (an object that can be swapped in to redirect property/method lookups, defaulting to owner), and a resolveStrategy (OWNER_FIRST by default, or DELEGATE_FIRST, OWNER_ONLY, DELEGATE_ONLY, SELF_ONLY) - this delegation mechanism is the foundation of Groovy DSLs such as Gradle build scripts and the builder pattern, where build.dependencies { implementation 'x' } resolves implementation against a delegate object rather than the closure's lexical owner.

🏏

Cricket analogy: Changing a closure's delegate is like a captain temporarily handing tactical calls to the vice-captain - instructions like field there or bowl this still get issued the same way, but they're now resolved against a different decision-maker than the closure's original owner.

A closure is an instance of groovy.lang.Closure - a first-class, reusable block of code.
The implicit parameter it is available when a closure declares no named parameters.
Closures close over (capture live references to) variables from their enclosing scope, including mutable local variables.
Trailing closure syntax lets a closure passed as the last argument sit outside the method's parentheses, e.g. 5.times { ... }.
owner is the enclosing object where a closure was defined; delegate can be swapped to redirect property/method resolution.
resolveStrategy (OWNER_FIRST, DELEGATE_FIRST, OWNER_ONLY, DELEGATE_ONLY, SELF_ONLY) controls how ambiguous calls inside a closure are resolved.
Delegation is the mechanism behind Groovy DSLs such as Gradle build scripts.