func f() Option {
    result, err := DoSomething()
    if err != nil {
        return Error("oops:", err)
    }
    return Data(result)
}

type Option interface {
    isOption()
}

type Data[T any] struct {
    Value T
}
func (Data[T]) isOption() {}

type Error struct {
    Err error
}
func (Error) isOption() {}

func DoSomething(b bool) Option {
    if b {
        return Data[int]{Value: 42}
    }
    return Error{
        Err: fmt.Errorf("oops"),
    }
}

func main() {
    opt := DoSomething(true)
    switch option := opt.(type) {
    case Data[int]:
        fmt.Println(option.Value)
    case Error:
        fmt.Println(option.Err)
    }
    default:
    }
}

//sumtype:decl
type Option interface {
    isOption()
}

go run -gcflags "-m" 
или 
go tools compile -m

version: '3'
services:
  jaeger:
    image: jaegertracing/all-in-one:latest
    ports:
      - "16686:16686" # UI
      - "14268:14268" # Collector
      - "14250:14250" # gRPC
      - "9411:9411"   # Zipkin

package main

import (
    "context"
    "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/jaeger"
    "go.opentelemetry.io/otel/sdk/resource"
    "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.7.0"
    "log"
    "math/rand"
    "net/http"
    "time"
)

func main() {
    // Initialize Jaeger Exporter
    exporter, err := jaeger.New(jaeger.WithCollectorEndpoint())
    if err != nil {
       log.Fatal(err)
    }

    // Create Trace Provider
    tp := trace.NewTracerProvider(
       trace.WithBatcher(exporter),
       trace.WithResource(resource.NewWithAttributes(
          semconv.SchemaURL,
          semconv.ServiceNameKey.String("app-one"),
       )),
    )

    otel.SetTracerProvider(tp)

    http.Handle("/", otelhttp.NewHandler(http.HandlerFunc(SimpleHandler), "Hello"))
    log.Fatal(http.ListenAndServe(":8081", nil))
}

func SimpleHandler(w http.ResponseWriter, r *http.Request) {
    _, _ = w.Write([]byte("Hello, World!"))
}

package main

type S struct {
    N int
}

func (s *S) PointerRcv() {
}

func (s S) ValueRcv() {
}

func main() {
    var s *S // s равно nil
    s.PointerRcv()
    s.ValueRcv()
}

package main

type S struct {
    N int
}

func PointerFunc(s *S) {
}

func ValueFunc(s S) {
}

func main() {
    var s *S 

    PointerFunc(s)
    ValueFunc(*s)
}

caddy reverse-proxy --from myserver.localhost --to :9000

myapp.localhost {
    reverse-proxy :9000
}

myhugoblog.localhost {
    reverse-proxy :1313
}

switch a {
    case 1: 
        fmt.Println("1")
    case 2:
        fmt.Println("2")
    default:
        fmt.Println("default")
}

switch a {
    case 1: 
        fmt.Println("1")
    case 2, 3, 4:
        fmt.Println("2, 3 или 4")
//  case 1,2:  // ошибка: дублирование case 1, дублирование case 2
//      fmt.Println("1 или 2")
}

switch a := f(); a {
    case 1: 
        fmt.Println("1")
    case 2:
        fmt.Println("2")
}

switch {
    case a == 1: 
        fmt.Println("1")
    case a >=2 && a <= 4:
        fmt.Println("2")
    case a <= 5:
        fmt.Println("3")
}

switch v := a.(type) {
    case int: 
        fmt.Println("a — это int:", v)
    case string, []byte:
        fmt.Println("a — это string:", v)
}

func do[T comparable](a any) {
    switch v := a.(type) {
    case int:
        fmt.Println("a — это int:", v)
    case T:
        fmt.Printf("a — это %T: %v", v, v)
    case []T:
        fmt.Println("a — это срез:", v)
    case []byte:
        fmt.Println("a — это срез байт:", v)
    }
}

func main() {
    do[bool](a)
    do[bool](true)
    do[int]([]int{1, 2, 3})
}

go test -cpu=4,5