verbose := flag.Bool("v", false, "Enable verbose mode")
flag.Parse()
if *verbose {
    fmt.Println("Verbose logging enabled")
}

flag.Parse()
fmt.Println("Remaining args:", flag.Args())

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")
}