Дженерики в Golang: параметры типа, ограничения и примеры

Обобщённая функция

Параметры типа пишутся в квадратных скобках перед обычными параметрами. У каждого есть ограничение, которое говорит, какие типы допустимы.

package main

import (
	"fmt"
	"strconv"
)

func Map[T, U any](items []T, f func(T) U) []U {
	out := make([]U, 0, len(items))
	for _, it := range items {
		out = append(out, f(it))
	}
	return out
}

func main() {
	nums := []int{1, 2, 3}

	squares := Map(nums, func(n int) int { return n * n })
	fmt.Println(squares)

	labels := Map(nums, strconv.Itoa)
	fmt.Printf("%q\n", labels)

	lengths := Map([]string{"go", "rust", "c"}, func(s string) int { return len(s) })
	fmt.Println(lengths)
}

T и U выводятся из аргументов, поэтому писать Map[int, string](...) приходится редко. Вывод работает по аргументам функции; тип, который встречается только в результате, вывести нельзя. Для func Zero[T any]() T нужно писать Zero[int]().

До Go 1.18 такую функцию приходилось писать отдельно для каждого типа или принимать []interface{} и терять типобезопасность.

Ограничения

Ограничение это интерфейс. Оно сужает круг допустимых типов и взамен сообщает компилятору, какие операции разрешены над значениями этого типа.

package main

import (
	"cmp"
	"fmt"
)

func Index[T comparable](s []T, target T) int {
	for i, v := range s {
		if v == target { // needs comparable
			return i
		}
	}
	return -1
}

func Largest[T cmp.Ordered](s []T) T {
	m := s[0]
	for _, v := range s[1:] {
		if v > m { // needs cmp.Ordered
			m = v
		}
	}
	return m
}

func main() {
	fmt.Println(Index([]string{"a", "b", "c"}, "c"))
	fmt.Println(Largest([]float64{2.5, 9.1, 4.0}))
	fmt.Println(Largest([]string{"pear", "apple", "zucchini"}))
}

С any вместо comparable выражение v == target не скомпилируется: invalid operation: v == target (incomparable types in type set). Именно ограничение делает оператор допустимым.

Обе эти функции уже существуют: slices.Index и slices.Max. Стандартные пакеты slices, maps и cmp покрывают большинство повседневных обобщённых задач, так что сначала загляните в них.

Свои ограничения: объединения типов и ~

Ограничение может перечислять типы через |. Разрешены операторы, которые поддерживает каждый из перечисленных типов.

package main

import "fmt"

type Number interface {
	~int | ~int64 | ~float64
}

func Sum[T Number](nums []T) T {
	var total T
	for _, n := range nums {
		total += n
	}
	return total
}

type Cents int64

func main() {
	fmt.Println(Sum([]int{1, 2, 3}))
	fmt.Println(Sum([]float64{0.5, 0.25}))
	fmt.Println(Sum([]Cents{199, 250})) // works because of ~int64
}

Тильда важна. ~int64 означает «любой тип, базовый тип которого int64», поэтому именованный тип Cents принимается. Если написать просто int64, Sum([]Cents{...}) упадёт с Cents does not satisfy Number (possibly missing ~ for int64 in Number).

Интерфейсы с объединениями типов можно использовать только как ограничения и никогда как обычные типы переменных. var n Number не компилируется.

В пакете golang.org/x/exp/constraints есть готовые ограничения Integer, Float и Signed. Он не входит в стандартную библиотеку, поэтому среда запуска на этой странице не может его импортировать; стандартное ограничение это cmp.Ordered.

Обобщённые типы

Структуры, слайсы, мапы и другие типы тоже могут иметь параметры типа. Методы обобщённого типа используют параметры получателя.

package main

import (
	"errors"
	"fmt"
)

type Stack[T any] struct {
	items []T
}

func (s *Stack[T]) Push(v T) {
	s.items = append(s.items, v)
}

func (s *Stack[T]) Pop() (T, error) {
	var zero T
	if len(s.items) == 0 {
		return zero, errors.New("empty stack")
	}
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, nil
}

func (s *Stack[T]) Len() int { return len(s.items) }

type Pair[K comparable, V any] struct {
	Key K
	Val V
}

func main() {
	var s Stack[string]
	s.Push("a")
	s.Push("b")
	v, _ := s.Pop()
	fmt.Println(v, s.Len())

	_, err := (&Stack[int]{}).Pop()
	fmt.Println(err)

	p := Pair[string, int]{Key: "age", Val: 31}
	fmt.Printf("%+v\n", p)
}

Две детали из этого примера встречаются постоянно:

• Нулевое значение T. var zero T это способ вернуть «ничего» из обобщённого кода. Не существует T{} или nil, которые подходили бы для любого типа.
• Инстанцирование. Обобщённый тип нужно инстанцировать перед использованием: Stack[string], а не Stack. Внутри его собственных методов получатель записывается как Stack[T].

В Go 1.24 появились обобщённые псевдонимы типов: type Set[T comparable] = map[T]struct{} теперь компилируется.

Ограничения, на которые вы наткнётесь

• У методов нет параметров типа. func (s *Stack[T]) Map[U any](...) не допускается. Используйте функцию верхнего уровня.
• Нет специализации. Нельзя написать отдельную реализацию для T = string. Обходной путь это type switch по any(v) внутри функции, и обычно это намёк, что дженерики здесь не тот инструмент.
• Нет ограничений по имени оператора. Нельзя сказать «любой тип с методом +»; типы перечисляются в объединении.
• Доступ к полям через ограничение не работает. Даже если у всех типов объединения есть поле ID, v.ID недопустимо. Используйте в ограничении метод.

Когда дженерики не нужны

Дженерики подходят для контейнеров (стеки, множества, кеши, деревья) и алгоритмов над слайсами и мапами, которые делают одно и то же для любого типа элементов. Подходят они не везде.

• Один конкретный тип. Если функцию вызывают только с []User, обобщённая версия лишь усложняет чтение.
• Поведение, различающееся по типу. Для этого есть интерфейсы. Функция, принимающая io.Writer, проще, чем функция с [T io.Writer], и работает так же.
• Замена параметров-интерфейсов. func Print[T fmt.Stringer](v T) ничем не лучше func Print(v fmt.Stringer).

Собственная рекомендация команды Go: сначала напишите код для конкретного типа, а к параметрам типа переходите, когда заметите, что пишете тот же код второй раз и меняются только типы.

Частые ошибки

• any там, где нужен comparable или cmp.Ordered. Компилятор отвергает == или < для параметра типа с ограничением any.
• Забытая ~. Пользовательские типы вроде type ID int не проходят ограничение, где написано просто int.
• Возврат nil для параметра типа. Не допускается, если ограничение не сводит T к типам, похожим на указатели. Возвращайте нулевое значение.
• Обобщённый помощник, который уже существует. Сначала проверьте slices, maps и cmp.