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

type Server struct {
    host     string
    port     int
    protocol string
}

func NewServer(host string, port int) *Server {
    return &Server{host: host, port: port, protocol: "http"}
}

type ServerOption func(*Server)

func WithPort(port int) ServerOption {
    return func(s *Server) {
        s.port = port
    }
}

func NewServer(host string, opts ...ServerOption) *Server {
    server := &Server{host: host, port: 443, protocol: "https"}
    for _, opt := range opts {
        opt(server)
    }
    return server
}

server1 := NewServer("localhost")               // с портом по умолчанию
server2 := NewServer("localhost", WithPort(8080)) // с портом 8080