type Value interface {
    String() string
    Set(string) error
}

type MyFlag struct{}
func (m *MyFlag) String() string { return "" }
func (m *MyFlag) Set(value string) error { fmt.Println("Set value:", value); return nil }

var my MyFlag
flag.Var(&my, "myflag", "custom flag")
flag.Parse()

func main() {
    var x interface{} = 42
    var y interface{} = "привет"
    var z interface{} = []int{1, 2, 3}
    
    fmt.Println(reflect.TypeOf(x))  // int
    fmt.Println(reflect.TypeOf(y))  // string
    fmt.Println(reflect.TypeOf(z))  // []int
}

func processValue(val interface{}) {
    if str, ok := val.(string); ok {
        fmt.Printf("Это строка: %s\n", str)
    } else if num, ok := val.(int); ok {
        fmt.Printf("Это число: %d\n", num)
    } else {
        fmt.Println("Неизвестный тип")
    }
}

func describe(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("Целое число: %d\n", v)
    case string:
        fmt.Printf("Строка длиной %d символов\n", len(v))
    case []int:
        fmt.Printf("Срез из %d элементов\n", len(v))
    case bool:
        fmt.Printf("Булево значение: %v\n", v)
    default:
        fmt.Printf("Неизвестный тип: %T\n", v)
    }
}

var data interface{} = map[string]int{"ключ": 100}
fmt.Printf("Тип переменной: %T\n", data)  // map[string]int

start := time.Now()
time.Sleep(2 * time.Second)
end := time.Now()

duration := end.Sub(start) // ≈ 2 секунды
fmt.Println(duration) // 2.001234567s

now := time.Now()
tomorrow := now.Add(24 * time.Hour)
yesterday := now.Add(-24 * time.Hour)

fmt.Println("Завтра:", tomorrow)
fmt.Println("Вчера:", yesterday)

for {
    select {
    case msg := <-messages:
        process(msg)
    case <-time.After(5 * time.Second):
        // проверяем что-то каждые 5 секунд
    }
}

timer := time.NewTimer(5 * time.Second)
defer timer.Stop()

for {
    select {
    case msg := <-messages:
        process(msg)
        timer.Reset(5 * time.Second)
    case <-timer.C:
        // проверка по таймауту
        timer.Reset(5 * time.Second)
    }
}

select {
case result := <-doWork():
    return result
case <-time.After(10 * time.Second):
    return errors.New("timeout")
}

var count int           // инициализируется нулевым значением (0)
var name string         // инициализируется "" (пустая строка)
var isActive bool       // инициализируется false
var users []User        // инициализируется nil

var total = 100         // тип выводится автоматически
var message string = "Hello"  // явное указание типа

func processOrder() {
    status := "pending"     // эквивалентно var status string = "pending"
    count := 42            // эквивалентно var count int = 42
    user := getUser()      // тип выводится из возвращаемого значения
}

ptr := new(int)         // *int, значение 0
fmt.Println(*ptr)       // 0

user := new(User)       // *User, все поля в нулевых значениях

// Эквивалентные записи:
ptr1 := new(int)
ptr2 := &int{}          // более идиоматично

user1 := new(User)
user2 := &User{}        // более наглядно

set := map[string]struct{}{}
set["apple"] = struct{}{}

done := make(chan struct{})
go func() {
    // работа
    done <- struct{}{}
}()
<-done

math.Round(2.5)  // 3
math.Round(2.4)  // 2
math.Round(-2.5) // -3
math.Floor(2.7) // 2 — всегда вниз
math.Ceil(2.1)  // 3 — всегда вверх
math.Trunc(2.9)  // 2
math.Trunc(-2.9) // -2

result := int(math.Round(2.5)) // 3

func roundToDecimal(num float64, precision int) float64 {
    shift := math.Pow(10, float64(precision))
    return math.Round(num * shift) / shift
}

roundToDecimal(3.14159, 2) // 3.14

import "github.com/shopspring/decimal"

num := decimal.NewFromFloat(3.14159)

num.Round(2)                           // 3.14
num.RoundUp(2)                         // 3.15 — всегда вверх
num.RoundDown(2)                       // 3.14 — всегда вниз
num.RoundBank(2)                       // банковское округление

num := new(big.Float).SetFloat64(3.14159)
rounded := new(big.Float)

// Устанавливаем точность и режим округления
rounded.SetPrec(53) // точность в битах
num.SetMode(big.ToNearestEven) // режим округления

// Выдать сдачу 63 рубля монетами: 50, 10, 5, 2, 1
// Жадный подход: берем максимальную монету
func giveChange(amount int) []int {
    coins := []int{50, 10, 5, 2, 1}
    result := []int{}
    
    for _, coin := range coins {
        for amount >= coin {
            result = append(result, coin)
            amount -= coin
        }
    }
    return result // [50, 10, 2, 1] - работает!
}