Explain the concept of closures in Groovy and how they can be used to achieve concise and expressive code.

In Groovy, closures are a powerful feature that allows you to define blocks of code as first-class objects. A closure is an anonymous function that can be assigned to variables, passed as arguments to other functions, and returned as values from functions. Closures capture the state of their surrounding environment, including variables and functions, which makes them useful for creating concise and expressive code.

Closures in Groovy offer several benefits and use cases:

1. Concise syntax: Closures provide a compact and readable syntax for defining functions. They eliminate the need for boilerplate code when creating small, one-off functions.
2. Code encapsulation: Closures encapsulate logic within a self-contained unit, making the code more modular and reusable. They allow you to define behavior specific to a particular context without polluting the global namespace.
3. Higher-order functions: Closures enable the use of higher-order functions, which are functions that take other functions as parameters or return functions as results. This functional programming technique promotes code flexibility and modularity.
4. Callbacks and event handling: Closures are commonly used as callbacks or event handlers. They can be passed as arguments to other functions or registered as listeners to respond to specific events or actions.
5. Iteration and collection processing: Closures are particularly useful for iterating over collections and performing operations on each element. They allow you to express complex operations succinctly, such as mapping, filtering, and reducing collections.
6. DSL construction: Closures play a vital role in building domain-specific languages (DSLs) in Groovy. They enable the creation of expressive and readable syntax tailored to specific problem domains, making the code more intuitive and natural to work with.

Here's an example to illustrate the use of closures in Groovy:

```
groovy`// Simple closure definition
def greet = { name ->
println "Hello, $name!"
}

// Invoking the closure
greet("John") // Output: Hello, John!

// Higher-order function using closures
def applyOperation = { operation, x, y ->
operation(x, y)
}

def add = { a, b -> a + b }
def subtract = { a, b -> a - b }

println applyOperation(add, 5, 3) // Output: 8
println applyOperation(subtract, 7, 2) // Output: 5

// Iteration using closures
def numbers = [1, 2, 3, 4, 5]
numbers.each { println it * 2 } // Output: 2, 4, 6, 8, 10

// DSL-like usage with closures
def person = {
name = "John"
age = 30
greet = { println "Hello, $name! You are $age years old." }
info = { println "Name: $name, Age: $age" }
}

person.greet() // Output: Hello, John! You are 30 years old.
person.info() // Output: Name: John, Age: 30`
```
Closures in Groovy allow you to write expressive and concise code by encapsulating behavior, promoting modularity, and enabling higher-order functions and DSL-like constructs. They enhance the readability and maintainability of your code, making it more flexible and adaptable to different programming scenarios.