Closures

You already know functions are values in Go — you can put one in a variable and pass it around. A closure takes that one step further: it's a function that remembers variables from the scope where it was created.

A function that captures its surroundings

When you write a function literal that mentions a variable from the enclosing scope, the function "closes over" that variable — hence closure:

package main

import "fmt"

func main() {
	message := "hi"
	greet := func() { fmt.Println(message) }
	message = "hello"
	greet() // hello
}

greet didn't copy message when it was defined; it captured the variable itself. Changing message afterward changes what greet prints. Closures capture by reference, not by value.

Captured variables outlive the outer call

Here's the surprising part. The captured variable stays alive as long as the closure does — even after the function that declared it has returned:

package main

import "fmt"

func makeCounter() func() int {
	count := 0
	return func() int {
		count++
		return count
	}
}

func main() {
	next := makeCounter()
	fmt.Println(next()) // 1
	fmt.Println(next()) // 2
	fmt.Println(next()) // 3
}

makeCounter returns and its stack frame is gone — yet count lives on, privately held by the returned closure. This "factory" pattern is the classic use of closures: bundle some hidden state with a function that operates on it.

Each closure has its own state

Every call to the factory makes a fresh variable, so the closures it returns are independent:

a := makeCounter()
b := makeCounter()
fmt.Println(a(), a(), b()) // 1 2 1

a and b count separately because each got its own count.

Why capture by reference?

Capturing the variable (not a snapshot) is what makes the counter work — every call has to see and update the same count. It's also the one thing to stay alert about: if several closures capture the same variable, they all see its latest value.

That used to bite people in for loops, where every closure captured the one shared loop variable. As of Go 1.22, each iteration gets its own copy of the loop variable, so a closure created inside the loop captures that iteration's value — the intuitive behavior, and one less footgun.