20 — Context

// import "golang.org/x/sync/errgroup"
// errgroup.Group runs goroutines and returns the FIRST error.
// It also provides bounded concurrency via SetLimit.

func fetchAll(ctx context.Context, urls []string) ([][]byte, error) {
    g, ctx := errgroup.WithContext(ctx)  // ctx canceled if any goroutine errors

    results := make([][]byte, len(urls))
    g.SetLimit(10)  // at most 10 concurrent goroutines

    for i, url := range urls {
        i, url := i, url  // capture (pre-1.22; 1.22+ doesn't need this)
        g.Go(func() error {
            data, err := fetch(ctx, url)
            if err != nil {
                return err  // cancels ctx and stops other goroutines
            }
            results[i] = data  // safe — each goroutine writes a distinct index
            return nil
        })
    }

    if err := g.Wait(); err != nil {
        return nil, err  // first error from any goroutine
    }
    return results, nil
}

💡 Tips & Tricks

• Idiom: always defer cancel() when using WithCancel/WithTimeout/WithDeadline — releases resources (timers, goroutines) even if the operation completes normally. Forgetting cancel leaks.
• Idiom: pass context.Context as the FIRST parameter of every function that does I/O or can be canceled — func f(ctx context.Context, ...). This is the universal Go convention; libraries expect it.
• Idiom: use context.Background() at the top level (main, tests) and r.Context() in HTTP handlers — Background is the root; r.Context() is canceled when the client disconnects.
• Idiom: include <-ctx.Done() in every long-running goroutine's select — it provides the exit path when the parent cancels. A goroutine that never checks ctx.Done() can't be canceled (leak).
• Idiom: use WithValue sparingly and only for cross-cutting concerns (request ID, trace ID) — it's untyped and encourages hidden coupling. Use a custom key type to avoid string collisions.
• Idiom: don't store contexts in structs — they're for flowing through call chains, not fields. A struct with a ctx field breaks cancellation propagation.

⚠️ Edge Cases & Gotchas

• Forgetting cancel leaks: WithTimeout/WithDeadline start a timer; not calling cancel leaves the timer alive until the deadline. defer cancel() is the fix.
• Don't store contexts in structs: contexts are for passing through call chains, not for keeping in fields. A struct with a ctx field is a code smell.
• ctx.Done() is a channel, not a value: <-ctx.Done() blocks until canceled; ctx.Err() gives the reason. Don't poll Done() — select on it.
• context.Background() is never canceled: it's the root. Derive from it with WithCancel/WithTimeout for cancellation.
• Canceling a parent cancels children: but canceling a child doesn't affect the parent or siblings. This is the tree structure.
• WithValue is untyped: ctx.Value(key) returns any — must type-assert. Use a custom key type to avoid collisions.
• context.TODO() vs context.Background(): TODO signals "I haven't decided which context to use yet" — it's a placeholder. Use Background for the actual root.
• Nil context is a panic: var ctx context.Context; ctx.Done() panics. Always pass a real context (Background at minimum).
• errgroup.WithContext cancels on first error: g.Go returns an error → the derived context is canceled → other goroutines see <-ctx.Done() and exit. This is coordinated error handling.

🧠 Quick Quiz

func handler(ctx context.Context) {
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    // ⚠️ no defer cancel()

    doWork(ctx)
}

func doWork(ctx context.Context) {
    time.Sleep(10 * time.Second)
}