var g singleflight.Group

func fetchData(key string) (any, error) {
    v, err, _ := g.Do(key, func() (any, error) {
        return loadFromDB(key) // выполнится только один раз
    })
    return v, err
}

import "golang.org/x/text/unicode/norm"

a := "é"       // precomposed
b := "e\u0301" // decomposed

// Без канонизации
fmt.Println(a == b) // false

// С канонизацией
normA := norm.NFC.String(a)
normB := norm.NFC.String(b)
fmt.Println(normA == normB) // true

type WriterTo interface {
    WriteTo(w io.Writer) (n int64, err error)
}

// 1. Источник умеет писать сам?
if wt, ok := src.(WriterTo); ok {
    return wt.WriteTo(dst)
}
// 2. Назначение умеет читать само?
if rf, ok := dst.(ReaderFrom); ok {
    return rf.ReadFrom(src)
}
// 3. Fallback — буфер 32KB

// Плохо: ctx может быть уже отменён
ctx := context.Background()
get := sync.OnceValue(func() *DB {
    return connect(ctx) // ctx захвачен в замыкании
})

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    for i := 0; i < 5; i++ {
        go func(id int) {
            for {
                select {
                case <-ctx.Done():
                    fmt.Printf("горутина %d остановлена\n", id)
                    return
                default:
                    fmt.Printf("горутина %d работает\n", id)
                    time.Sleep(500 * time.Millisecond)
                }
            }
        }(i)
    }

    time.Sleep(2 * time.Second)
    cancel()
    time.Sleep(100 * time.Millisecond)
}

var a []int
a = append(a, 4, 5, 6) // Go выделяет память сам
fmt.Println(a)          // [4 5 6]

var m map[int]int
// m[1] = 1  ← паника!

m = make(map[int]int)
m[1] = 1 // теперь работает