var Pi = 3.14  // экспортируемая
var radius = 5 // неэкспортируемая

m := make(map[string]int)
m["a"] = 1
m["b"] = 2

m := map[string]int{
    "a": 1,
    "b": 2,
}

var mu sync.Mutex
mu.Lock()
m["a"] = 1
mu.Unlock()

panic: interface conversion: <interface type> is <actual type>, not <expected type>

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

type ReadWriter interface {
    Reader
    Writer
}

file, err := os.Open("file.txt")
if err != nil {
    // обработка ошибки
}
defer file.Close()

func example() {
    defer fmt.Println("1")
    defer fmt.Println("2")
    fmt.Println("Function body")
}

func example(a int) {
    defer fmt.Println(a)
    a *= 2
    return
}
example(5) // Выведет: 5

func mightPanic() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    // код, который может вызвать панику
}

p := new(int)

s := make([]int, 5, 10) 

m := make(map[string]int)

ch := make(chan int)

type Engine struct {
    Power int
    Type  string
}

type Car struct {
    Engine  
    Brand   string
    Model   string
}

func main() {
    c := Car{
        Engine: Engine{Power: 150, Type: "Petrol"},
        Brand:  "Ford",
        Model:  "Fiesta",
    }
    fmt.Println(c.Power) // Выведет: 150
}

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

type Logger struct {
    Writer
}

arr1 := [5]int{}
arr2 := [...]int{1, 2, 3}
arr3 := [...]int{}

package main

import (
    "fmt"
    "sync"
)

type singleton struct {
    data string
}

var (
    instance *singleton
    mu       sync.Mutex
)

func GetInstance() *singleton {
    if instance == nil {
        mu.Lock()
        defer mu.Unlock()
        if instance == nil {
            instance = &singleton{data: "initialized"}
        }
    }
    return instance
}

func main() {
    s := GetInstance()
    fmt.Println("Singleton data:", s.data)
}

ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()