Function Literals & Closures

A function literal is an anonymous function expression you can define and invoke inline.

When it references variables from surrounding scopes, it becomes a closure that carries those bindings into later execution - including goroutines and deferred calls.

Summary

Function literals enable local callbacks, middleware, and factories without declaring named top-level functions.

Closures capture variables by reference, not by snapshot, unless you copy loop variables or pass parameters explicitly.

The classic goroutine bug launches multiple closures sharing one loop variable.

Factories return configured closures (rate limiters, validators) while hiding mutable state in the outer function.

Use literals for short, local behavior; promote to named functions when logic grows or needs testing in isolation.

Recipe

Quick-reference recipe card - copy-paste ready.

func withTimeout(parent context.Context, d time.Duration) (context.Context, context.CancelFunc) {
    return context.WithTimeout(parent, d)
}
 
func middleware(log func(string)) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            log(r.Method + " " + r.URL.Path)
            next.ServeHTTP(w, r)
        })
    }
}
 
// Safe goroutine spawn in a loop.
for _, id := range ids {
    id := id
    go func() {
        process(id)
    }()
}

When to reach for this:

• HTTP/gRPC middleware wrapping handlers.
• defer needs a local function adjusting cleanup behavior.
• Sorting with slices.SortFunc / sort.Slice comparators.
• Tests supply inline stubs implementing small interfaces.

Working Example

package ratelimit
 
import (
    "context"
    "sync"
    "time"
)
 
type Limiter func(ctx context.Context) error
 
func New(interval time.Duration) Limiter {
    var mu sync.Mutex
    var last time.Time
    return func(ctx context.Context) error {
        mu.Lock()
        defer mu.Unlock()
        now := time.Now()
        wait := interval - now.Sub(last)
        if wait > 0 {
            timer := time.NewTimer(wait)
            defer timer.Stop()
            select {
            case <-ctx.Done():
                return ctx.Err()
            case <-timer.C:
            }
        }
        last = time.Now()
        return nil
    }
}
 
func Example(ctx context.Context) error {
    wait := New(100 * time.Millisecond)
    for i := 0; i < 3; i++ {
        if err := wait(ctx); err != nil {
            return err
        }
    }
    return nil
}

What this demonstrates:

• Factory New returns a closure hiding mu and last.
• Captured state serializes callers without exporting a struct.
• Context respected during waits inside the closure.
• Mutex protects shared variables across goroutines invoking the same Limiter.

Deep Dive

How It Works

• Function literals compile to heap-allocated function values when they escape (stored, returned, sent to goroutines).
• Free variables are captured by reference through hidden pointers in the closure struct.
• Named functions can close over package-level vars; literals commonly close over locals in the enclosing function.
• go statement schedules the closure - capture semantics matter at schedule time, not only at definition time.

Capture Pitfalls and Fixes

Factory vs Struct

Go Notes

sort.Slice(items, func(i, j int) bool {
    return items[i].Priority < items[j].Priority
})

Literals excel for one-off comparators and filters.

Extract when reused across packages.

Gotchas

• Loop variable capture in goroutines - Classic data race on loop index/item. Fix: shadow with v := v or pass as parameter.
• Defer in loop without closure wrapper - All defers run at outer function end, not per iteration. Fix: func(){ defer cleanup(); work() }().
• Nil closure invocation - Assigning uninitialized func() panics. Fix: guard or require constructor.
• Capturing pointers to loop variables - &v in loop shares one address. Fix: copy value inside loop body before taking address.
• Closure retains large objects - Prevents GC of captured maps/slices longer than needed. Fix: narrow capture to IDs or interfaces.
• Testing anonymous logic - Hard to target without exporting. Fix: name function or inject interface when complexity grows.
• sync.WaitGroup + goroutine closure - Forgetting Add before go races. Fix: call Add before launch; use defer Done() inside goroutine.

Alternatives

FAQs

Related

• Variadic Functions & Function Types - naming function types and middleware
• Functions & Methods Basics - safe loop capture example
• Methods: Value vs Pointer Receivers - HandlerFunc method pattern
• Functions and Interfaces: Go's Composition Model - composing behavior with functions
• Functions, Methods & Interfaces Best Practices - goroutine and middleware guidance

Stack versions: This page was written for Go 1.26.x (Green Tea GC default, go fix modernizers - verify patch at build), chi (latest - verify at build), gin (latest - verify at build), echo (latest - verify at build), google.golang.org/grpc (latest - verify at build), sigs.k8s.io/controller-runtime (latest - verify at build), kubebuilder (latest - verify at build), tinygo (latest - verify board targets at build), wazero (latest - verify at build), and golangci-lint (latest - verify linter set at build).