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()

package main

import (
    "fmt"
    "sync"
)

type singleton struct {
    config string
}

var (
    once     sync.Once
    instance *singleton
)

func GetInstance() *singleton {
    once.Do(func() {
        instance = &singleton{config: "default"}
    })
    return instance
}

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

go func(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("goroutine stopped:", ctx.Err())
            return
        case <-time.After(1 * time.Second):
            fmt.Println("working...")
        }
    }
}(ctx)

package main

import (
    "fmt"
)

type singleton struct {
    config string
}

var instance *singleton

func init() {
    instance = &singleton{config: "preloaded"}
}

func GetInstance() *singleton {
    return instance
}

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

ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
defer cancel()

select {
case msg := <-ch1:
    fmt.Println("Received from ch1:", msg)
case ch2 <- 42:
    fmt.Println("Sent 42 to ch2")
default:
    fmt.Println("Nothing ready")
}

type Storage interface {
    Get(key string) string
}

func ProcessData(s Storage) { ... }

// В тестовых сборках
func resetSingleton() {
    instance = nil
    once = sync.Once{}
}

select {
case msg := <-ch1:
    fmt.Println("ch1:", msg)
case msg := <-ch2:
    fmt.Println("ch2:", msg)
}