func RecoverMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("panic: %v\n%s", err, debug.Stack())
                http.Error(w, "Internal Server Error", 500)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

x := 1
defer fmt.Println(x) // Captures x=1 NOW
x = 2
// Prints: 1 (not 2)

x := 1
defer func() { fmt.Println(x) }() // Closure captures &x
x = 2
// Prints: 2 (closure reads x at execution time)

for _, file := range files {
    f, _ := os.Open(file)
    defer f.Close() // BAD: defers accumulate, files not closed until function returns
}
// Fix: wrap in a helper function or close explicitly

a := []int{1, 2, 3, 4, 5}
b := a[1:3] // b = [2, 3], but shares backing array with a
b[0] = 99   // a is now [1, 99, 3, 4, 5]!

a := make([]int, 3, 5) // len=3, cap=5
b := a[:3]
b = append(b, 99) // Writes into a's backing array at index 3!

b := a[1:3:3] // len=2, cap=2 — any append to b will allocate a new array

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel() // ALWAYS defer cancel to release resources

req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
resp, err := client.Do(req)
if err != nil {
    // Could be: context.DeadlineExceeded or context.Canceled
}

go build -gcflags="-m" ./...         # Basic escape analysis output
go build -gcflags="-m -m" ./...      # Verbose (shows reasoning)
go build -gcflags="-l" ./...         # Disable inlining (useful for testing)

select {
case msg := <-ch:
    process(msg)
case <-time.After(1 * time.Second):
    return errors.New("timeout")
}

select {
case ch <- value:
    // sent
default:
    // channel full or no receiver, drop or buffer
}

for {
    select {
    case <-ctx.Done():
        return ctx.Err()
    case item := <-workCh:
        process(item)
    }
}

// Check high-priority first
select {
case <-highPriority:
    handleHigh()
default:
    select {
    case <-highPriority:
        handleHigh()
    case <-lowPriority:
        handleLow()
    }
}

func merge(ch1, ch2 <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for ch1 != nil || ch2 != nil {
            select {
            case v, ok := <-ch1:
                if !ok { ch1 = nil; continue }
                out <- v
            case v, ok := <-ch2:
                if !ok { ch2 = nil; continue }
                out <- v
            }
        }
    }()
    return out
}

var once sync.Once
closeCh := func() { once.Do(func() { close(ch) }) }

func workerPool(numWorkers int, jobs <-chan Job) <-chan Result {
    results := make(chan Result, len(jobs))
    var wg sync.WaitGroup

    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- process(job)
            }
        }()
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    return results
}

sem := make(chan struct{}, maxConcurrency)
for _, job := range jobs {
    sem <- struct{}{} // Acquire
    go func(j Job) {
        defer func() { <-sem }() // Release
        process(j)
    }(job)
}

var wg sync.WaitGroup
for i := 0; i < n; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        doWork()
    }()
}
wg.Wait()

g, ctx := errgroup.WithContext(ctx)
for _, url := range urls {
    g.Go(func() error { return fetch(ctx, url) })
}
if err := g.Wait(); err != nil { /* first error */ }

type SafeMap struct {
    mu sync.RWMutex
    data map[string]int
}

var once sync.Once
var config *Config

func GetConfig() *Config {
    once.Do(func() {
        config = loadConfigFromDisk()
    })
    return config
}

var initErr error
once.Do(func() {
    config, initErr = loadConfig()
})
if initErr != nil { return initErr }

getConfig := sync.OnceValue(func() *Config {
    return loadConfig()
})
cfg := getConfig() // Thread-safe, computed once

var counter atomic.Int64
counter.Add(1)
val := counter.Load()

var configVal atomic.Value
configVal.Store(loadConfig())

// Hot reload:
go func() {
    for range ticker.C {
        configVal.Store(loadConfig())
    }
}()

// Read:
cfg := configVal.Load().(*Config)

go test -race ./...       # Run tests with race detection
go run -race main.go      # Run program with race detection
go build -race -o app     # Build binary with race detection

type Writer interface {
    Write(p []byte) (n int, err error)
}

// os.File implements Writer because it has a Write method
// bytes.Buffer implements Writer because it has a Write method
// Neither declares "implements Writer"

type eface struct {
    _type *_type  // Pointer to type metadata (size, hash, methods, etc.)
    data  unsafe.Pointer  // Pointer to the actual value
}

type iface struct {
    tab  *itab  // Pointer to interface table (itab): interface type + concrete type + method pointers
    data unsafe.Pointer
}

var _ io.Reader = (*MyType)(nil) // Compile error if MyType doesn't implement io.Reader

var p *int = nil         // nil pointer to int
var i interface{} = p    // interface contains (*int, nil)
fmt.Println(i == nil)    // FALSE! type is *int, value is nil

var j interface{}        // truly nil: type=nil, value=nil
fmt.Println(j == nil)    // TRUE

func getError() error {
    var err *MyError = nil
    return err  // Returns non-nil error interface containing (*MyError, nil)!
}

if getError() != nil {
    // This ALWAYS executes! The error interface is never nil
    fmt.Println("got error") // Oops
}

func getError() error {
    var err *MyError = nil
    if err != nil {
        return err
    }
    return nil  // Return bare nil — the interface will be truly nil
}

type Logger struct {}
func (l Logger) Log(msg string) { fmt.Println(msg) }

type Server struct {
    Logger          // Embedded (promoted) — NOT "extends" or "inherits"
    port int
}

s := Server{port: 8080}
s.Log("starting") // Works — Logger.Log is promoted to Server

type ReadWriter interface {
    io.Reader   // Embeds Reader interface
    io.Writer   // Embeds Writer interface
}

type MockDB struct {
    UserStore // Embed the interface — provides default nil implementations
}
func (m *MockDB) GetUser(id string) (*User, error) {
    return &User{Name: "mock"}, nil
}
// MockDB satisfies UserStore — only GetUser is overridden, other methods panic with nil pointer

type Server struct {
    port    int
    timeout time.Duration
    logger  *log.Logger
}

type Option func(*Server)

func WithPort(p int) Option {
    return func(s *Server) { s.port = p }
}

func WithTimeout(t time.Duration) Option {
    return func(s *Server) { s.timeout = t }
}

func NewServer(opts ...Option) *Server {
    s := &Server{
        port:    8080,         // sensible defaults
        timeout: 30 * time.Second,
    }
    for _, opt := range opts {
        opt(s)
    }
    return s
}

// Usage:
srv := NewServer(WithPort(9090), WithTimeout(5*time.Second))

m := new(map[string]int) // *m is nil — m["key"] panics
m := make(map[string]int) // m is initialized — m["key"] = 1 works

// Layer 1: Database
return fmt.Errorf("query users: %w", err)

// Layer 2: Service
return fmt.Errorf("get active users: %w", err)

// Layer 3: Handler
return fmt.Errorf("handle /users request: %w", err)

// Result: "handle /users request: get active users: query users: connection refused"

func fanIn(ctx context.Context, channels ...<-chan string) <-chan string {
    out := make(chan string)
    var wg sync.WaitGroup

    for _, ch := range channels {
        wg.Add(1)
        go func(c <-chan string) {
            defer wg.Done()
            for {
                select {
                case <-ctx.Done():
                    return
                case val, ok := <-c:
                    if !ok { return }
                    select {
                    case out <- val:
                    case <-ctx.Done():
                        return
                    }
                }
            }
        }(ch)
    }

    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

// Stage 1: Generate values
func gen(ctx context.Context, nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, n := range nums {
            select {
            case out <- n:
            case <-ctx.Done():
                return
            }
        }
    }()
    return out
}

// Stage 2: Transform (square each value)
func square(ctx context.Context, in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for n := range in {
            select {
            case out <- n * n:
            case <-ctx.Done():
                return
            }
        }
    }()
    return out
}

// Compose the pipeline:
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
for val := range square(ctx, gen(ctx, 1, 2, 3, 4)) {
    fmt.Println(val) // 1, 4, 9, 16
}

func main() {
    // Create a context that cancels on SIGINT/SIGTERM
    ctx, stop := signal.NotifyContext(context.Background(),
        syscall.SIGINT, syscall.SIGTERM)
    defer stop()

    srv := &http.Server{
        Addr:         ":8080",
        Handler:      router(),
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  120 * time.Second,
    }

    // Start server in background
    go func() {
        log.Println("server starting on :8080")
        if err := srv.ListenAndServe(); err != http.ErrServerClosed {
            log.Fatalf("server error: %v", err)
        }
    }()

    // Wait for shutdown signal
    <-ctx.Done()
    log.Println("shutdown signal received")

    // Give in-flight requests a deadline to complete
    shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := srv.Shutdown(shutdownCtx); err != nil {
        log.Printf("forced shutdown: %v", err)
    }

    // Clean up other resources (DB connections, message queues, etc.)
    db.Close()
    log.Println("server stopped cleanly")
}

func reverse(s string) string {
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}

s := "Hello, 世界"
// Byte reverse: garbled UTF-8 — multi-byte characters are split
// Rune reverse: "界世 ,olleH" — correct

val, ok := m["key"]
if ok {
    // key exists, val is the value
}

// Shorter idiom when you don't need the value:
if _, ok := m["key"]; ok {
    // key exists
}

m := map[string]int{"score": 0}
v := m["score"]   // v = 0 — is the score 0 or missing?
v := m["missing"] // v = 0 — same result, different meaning!

var (
    once     sync.Once
    instance *Config
)

func GetConfig() *Config {
    once.Do(func() {
        instance = &Config{
            Port:    8080,
            Timeout: 30 * time.Second,
        }
    })
    return instance
}

// Instead of GetConfig() singleton everywhere:
func NewServer(cfg *Config) *Server { ... } // Inject config

limiter := time.Tick(200 * time.Millisecond) // 5 req/sec
for req := range requests {
    <-limiter   // Block until next tick
    process(req)
}

import "golang.org/x/time/rate"

// 10 requests/sec, burst of 30
limiter := rate.NewLimiter(rate.Limit(10), 30)

func handleRequest(w http.ResponseWriter, r *http.Request) {
    if !limiter.Allow() {
        http.Error(w, "rate limited", http.StatusTooManyRequests)
        return
    }
    // Or use limiter.Wait(ctx) to block until allowed
    process(r)
}

type ClientLimiter struct {
    mu       sync.Mutex
    limiters map[string]*rate.Limiter
}

func (cl *ClientLimiter) GetLimiter(clientID string) *rate.Limiter {
    cl.mu.Lock()
    defer cl.mu.Unlock()
    if l, ok := cl.limiters[clientID]; ok {
        return l
    }
    l := rate.NewLimiter(10, 30)
    cl.limiters[clientID] = l
    return l
}

func Logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        // Wrap ResponseWriter to capture status code
        wrapped := &statusRecorder{ResponseWriter: w, status: 200}
        next.ServeHTTP(wrapped, r)
        log.Printf("%s %s %d %s", r.Method, r.URL.Path,
            wrapped.status, time.Since(start))
    })
}

type statusRecorder struct {
    http.ResponseWriter
    status int
}

func (r *statusRecorder) WriteHeader(code int) {
    r.status = code
    r.ResponseWriter.WriteHeader(code)
}

handler := Logging(Auth(RateLimit(myHandler)))

// Or with a helper:
func Chain(h http.Handler, mw ...func(http.Handler) http.Handler) http.Handler {
    for i := len(mw) - 1; i >= 0; i-- {
        h = mw[i](h)
    }
    return h
}
handler := Chain(myHandler, Logging, Auth, RateLimit)

func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        want     int
    }{
        {"positive", 1, 2, 3},
        {"zeros", 0, 0, 0},
        {"negative", -1, -2, -3},
        {"mixed", -1, 2, 1},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := Add(tt.a, tt.b)
            if got != tt.want {
                t.Errorf("Add(%d, %d) = %d; want %d",
                    tt.a, tt.b, got, tt.want)
            }
        })
    }
}

type User struct {
    Name      string
    CreatedAt time.Time
    Role      string
}

func (u User) MarshalJSON() ([]byte, error) {
    // Create an anonymous struct to avoid infinite recursion
    type Alias User
    return json.Marshal(struct {
        Alias
        CreatedAt string `json:"created_at"`
        Role      string `json:"role"`
    }{
        Alias:     Alias(u),
        CreatedAt: u.CreatedAt.Format("2006-01-02"),
        Role:      strings.ToUpper(u.Role),
    })
}

func (u *User) UnmarshalJSON(data []byte) error {
    type Alias User
    aux := &struct {
        *Alias
        CreatedAt string `json:"created_at"`
    }{Alias: (*Alias)(u)}

    if err := json.Unmarshal(data, aux); err != nil {
        return err
    }
    t, err := time.Parse("2006-01-02", aux.CreatedAt)
    if err != nil {
        return fmt.Errorf("parsing created_at: %w", err)
    }
    u.CreatedAt = t
    return nil
}

// Pre-1.22 bug:
for _, v := range items {
    go func() {
        fmt.Println(v) // All goroutines print the LAST value of v
    }()
}

for _, v := range items {
    v := v // New variable per iteration
    go func() {
        fmt.Println(v) // Correct: each goroutine has its own v
    }()
}

func getFirstTwo(data []byte) []byte {
    return data[:2] // Still references the entire backing array!
}

// If data was 100MB, the returned 2-byte slice keeps 100MB alive

func getFirstTwo(data []byte) []byte {
    result := make([]byte, 2)
    copy(result, data[:2])
    return result // Only references a 2-byte backing array
}

a := make([]int, 3, 6) // len=3, cap=6
b := a[:3]
b = append(b, 99) // Writes into a's backing array at index 3!

// Instead of:
func init() { db = connectDB() }

// Do:
func main() {
    db, err := connectDB()
    if err != nil { log.Fatal(err) }
}

type Stringer interface { String() string }

type MyType struct { Name string }
func (m *MyType) String() string { return m.Name }

var s Stringer
s = &MyType{"hello"} // OK: *MyType has String()
s = MyType{"hello"}  // COMPILE ERROR: MyType does not have String()

for i, v := range slice {
    // i and v are the SAME variable, updated each iteration
    // Closures capture the variable, not the value
}

for i, v := range slice {
    // i and v are NEW variables each iteration
    // Closures capture independent values
}