info := ProgInfo{0, 1, 2, 3}

info := ProgInfo{
    Flags:    0,
    Reguse:   1,
    Regset:   2,
    Regindex: 3,
}

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()

    newTime := now.Add(2 * time.Hour)
    fmt.Println("Time after 2 hours:", newTime)
    newTime = now.Add(-2 * time.Hour)
    fmt.Println("Time before 2 hours:", newTime)

    duration := newTime.Sub(now)
    fmt.Println("Duration newTime to now:", duration)
}

data := "test data"

Post(url string, contentType string, body io.Reader) (resp *http.Response, err error)

type Reader interface {
    Read(p []byte) (n int, err error)
}

func main() {
    data := "test data"
  
    contentType := "text/plain"
  
    body := strings.NewReader(data)
    // или 
    // body := bytes.NewBufferString(data)
  
    resp, err := http.Post("https://example.com", contentType, body)
 
    // ....
}

type sigFunc func(a int, b float64) (bool, error)

func functionA(a int, b float64) (bool, error) {
    return true, nil
}

func functionB(a int, b float64) (bool, error) {
    return false, nil
}

func main() {
    var x sigFunc = functionA
    x = functionB
    print(x)
}

package main

import (
    "sync"
)

func mergeChannels(channels ...chan int) chan int {
    var wg sync.WaitGroup
    mergedChannel := make(chan int)

    // Функция для чтения данных из канала и отправки их в объединенный канал.
    output := func(c chan int) {
        for n := range c {
            mergedChannel <- n
        }
        wg.Done()
    }

    wg.Add(len(channels))
    for _, c := range channels {
        go output(c)
    }

    // Закрытие объединенного канала после того, как все данные из входных каналов будут обработаны.
    go func() {
        wg.Wait()
        close(mergedChannel)
    }()

    return mergedChannel
}

func main() {
    // Пример использования функции mergeChannels
    c1 := make(chan int)
    c2 := make(chan int)

    // Запуск примера с фиктивным заполнением каналов
    go func() {
        for _, n := range []int{1, 2, 3} {
            c1 <- n
        }
        close(c1)
    }()
    go func() {
        for _, n := range []int{4, 5, 6} {
            c2 <- n
        }
        close(c2)
    }()

    merged := mergeChannels(c1, c2)
    for n := range merged {
        println(n)
    }
}

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

func stringToBytes(s string) []byte {
    // Получаем строковый заголовок
    stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&s))

    // Преобразуем его в заголовок среза байтов
    sliceHeader := reflect.SliceHeader{
        Data: stringHeader.Data,
        Len:  stringHeader.Len,
        Cap:  stringHeader.Len,
    }

    // Возвращаем срез, созданный на основе заголовка среза
    return *(*[]byte)(unsafe.Pointer(&sliceHeader))
}

func main() {
    s := "Hello, World!"
    b := stringToBytes(s)

    fmt.Println(s)  // Выведет: Hello, World!
    fmt.Println(b)  // Выведет: [72 101 108 108 111 44 32 87 111 114 108 100 33]
}

package main

import (
 "fmt"
)

func processNumbers(input <-chan int, output chan<- int) {
 for num := range input {
  // Пример операции: умножаем число на 2
  result := num * 2
  output <- result
 }
 close(output)
}

func main() {
 inputChannel := make(chan int)
 outputChannel := make(chan int)

 go processNumbers(inputChannel, outputChannel)

 // Отправляем числа в первый канал
 go func() {
  for i := 1; i <= 5; i++ {
   inputChannel <- i
  }
  close(inputChannel)
 }()

 // Читаем результаты из второго канала
 for result := range outputChannel {
  fmt.Println(result)
 }
}

newSlice := append(slice[:index], slice[index+1:]...)

slice[index] = slice[len(slice)-1]
newSlice := slice[:len(slice)-1]

newSlice := slice[1:]

newSlice := slice[:len(slice)-1]

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Преобразование строки в целое число
    strInt := "123"
    intValue, err := strconv.Atoi(strInt)
    if err != nil {
        fmt.Println("Ошибка преобразования:", err)
    } else {
        fmt.Println("Целое число:", intValue)
}

    // Преобразование строки в число с плавающей точкой
    strFloat := "123.45"
    floatValue, err := strconv.ParseFloat(strFloat, 64) // 64 указывает на то, что результат будет float64
    if err != nil {
        fmt.Println("Ошибка преобразования:", err)
    } else {
        fmt.Println("Число с плавающей точкой:", floatValue)
    }
}

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Преобразование целого числа в строку
    intValue := 123
    strInt := strconv.Itoa(intValue)
    fmt.Println("Строка:", strInt)

    // Преобразование числа с плавающей точкой в строку
    floatValue := 123.45
    strFloat := fmt.Sprintf("%f", floatValue)
    fmt.Println("Строка:", strFloat)
}