How do closures work in Go?

Question

Accepted Answer

A **closure** is a function that references variables from its surrounding scope, "closing over" them — the function retains access to those variables even after the enclosing function returns. Go functions are first-class values, making closures a common and powerful tool.

## A basic closure

```go
func makeCounter() func() int {
    count := 0                  // a local variable
    return func() int {          // this inner function CLOSES OVER count
        count++                  // it can read AND modify count
        return count
    }
}

counter := makeCounter()
fmt.Println(counter())   // 1
fmt.Println(counter())   // 2 — count PERSISTS between calls (state is retained)

other := makeCounter()    // a NEW, independent closure with its own count
fmt.Println(other())     // 1 — separate state
```

The returned function keeps a reference to `count` even after `makeCounter` returns — so the state persists across calls. Each call to `makeCounter` creates a fresh, independent `count`. This is encapsulated private state.

## Closures capture variables by REFERENCE (key point)

```go
// closures capture the variable itself, not a snapshot of its value
x := 10
f := func() int { return x }
x = 20
fmt.Println(f())   // 20 — sees the CURRENT value of x, not 10
```

## The classic loop-variable gotcha

```go
// ⚠️ in Go versions BEFORE 1.22:
funcs := []func(){}
for i := 0; i < 3; i++ {
    funcs = append(funcs, func() { fmt.Println(i) })  // all close over the SAME i
}
for _, f := range funcs { f() }   // prints 3, 3, 3 (not 0, 1, 2)! — all share i

// the classic fix (pre-1.22): make a per-iteration copy
for i := 0; i < 3; i++ {
    i := i                          // shadow with a new variable each iteration
    funcs = append(funcs, func() { fmt.Println(i) })
}
// Note: Go 1.22+ changed loop semantics so each iteration gets a NEW variable — this bug is fixed.
```

This is a famous bug: closures in a loop all captured the *same* loop variable. (Go 1.22 fixed the loop-variable scoping, but understanding the issue matters for older code and other captured variables.)

## Common uses of closures

```go
// 1. as callbacks / handlers
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { ... })

// 2. deferred functions capturing local state
defer func() { fmt.Println("cleanup with", localVar) }()

// 3. function factories (configured behavior)
func multiplier(factor int) func(int) int {
    return func(n int) int { return n * factor }
}
double := multiplier(2)   // double(5) → 10
```

## Why it matters

Closures are a powerful, frequently-used Go feature enabled by first-class functions — they let you create functions that carry private, persistent state (counters, generators, configured behaviors via factory functions) and are essential for callbacks, HTTP handlers, deferred cleanup that references local variables, and functional patterns.

Understanding that closures capture variables **by reference** (seeing current values, sharing state) — not by value — is crucial both for using them effectively (encapsulated mutable state) and for avoiding the **classic loop-variable capture bug** (all closures sharing one variable, a notorious source of confusion, since fixed in Go 1.22 but still relevant for older code and non-loop captures).

Closures appear throughout idiomatic Go and standard-library APIs, making them important practical knowledge and a recurring interview topic.