Самое интересное в новой версии Go — 1.27

Содержание

Generic methods — дженерики добрались до методов

type Result[T any] struct {
	Value T
	Err error
}

func MapResult[T, U any](r Result[T], f func(T) U) Result[U] {
	if r.Err != nil {
		return Result[U]{Err: r.Err}
	}

	return Result[U]{Value: f(r.Value)}
}

func main() {
	r := Result[int]{Value: 42}

	formatted := MapResult(r, strconv.Itoa)
	fmt.Println(formatted.Value)
}

func (r Result[T]) Map[U any](f func(T) U) Result[U] {
	if r.Err != nil {
		return Result[U]{Err: r.Err}
	}

	return Result[U]{Value: f(r.Value)}
}

func main() {
	r := Result[int]{Value: 42}

	formatted := r.Map(strconv.Itoa)
	fmt.Println(formatted.Value)
}	

type Mapper interface {
	Map[T any](func(string) T) T
}

Promoted fields в struct literals

type Address struct {
	City string
	ZipCode string
}

type User struct {
	Name string
	Address
}

user := User{
	Name: "Ivan",
	Address: Address{
		City: "Moscow",
	},
}

user := User{
	Name: "Ivan",
	City: "Moscow",
}

Улучшенный type inference для generic-функций

type Handler func(string)

func Handle[T any](value T) {
	fmt.Println(value)
}

var handler Handler
handler = Handle

handlers := []Handler{
	Handle[string],
}

handlers := []Handler{
	Handle,
}

encoding/json/v2 стал доступен без экспериментального флага

import json "encoding/json/v2"


type User struct {
	Name string `json:"name"`
	Admin bool `json:"admin"`
}


func main() {
	data, err := json.Marshal(User{
		Name: "Ivan",
		Admin: true,
	})
	if err != nil {
		log.Fatal(err)
	}


	fmt.Println(string(data))
}

input := []byte(`{
	"name": "Ivan",
	"admin": true,
	"unexpected": 42
}`)

var user User
err := json.Unmarshal(input, &user)

var user User
err := json.Unmarshal(
	input,
	&user,
	json.RejectUnknownMembers(true),
)
if err != nil {
	log.Fatal(err)
}

UUID теперь есть в стандартной библиотеке

import "uuid"


func main() {
	id := uuid.New()
	fmt.Println(id)
}

type UUID [16]byte

users := map[uuid.UUID]string{}

id := uuid.New()
users[id] = "Ivan"

if id == uuid.Nil() {
	fmt.Println("empty uuid")
}

randomID := uuid.NewV4()
orderedID := uuid.NewV7()

id, err := uuid.Parse("f81d4fae-7dec-11d0-a765-00a0c91e6bf6")
if err != nil {
	log.Fatal(err)
}

fmt.Println(id.String())

Runtime умеет находить утечки горутин

type result struct {
	value string
	err error
}


func process(items []string) ([]string, error) {
	ch := make(chan result)


	for _, item := range items {
		go func() {
			value, err := processItem(item)
			ch <- result{value: value, err: err}
		}()
	}


	var values []string
	for range len(items) {
		r := <-ch
		if r.err != nil {
			return nil, r.err
		}
		values = append(values, r.value)
	}


	return values, nil
}

profile := pprof.Lookup("goroutineleak")
if profile == nil {
	log.Fatal("goroutine leak profile is unavailable")
}

if err := profile.WriteTo(os.Stdout, 1); err != nil {
	log.Fatal(err)
}

Ускорение небольших аллокаций

Переносимый SIMD

go test проверяет версию стандартной библиотеки

go mod tidy приводит require к стандартной структуре

Финальные мысли