Generyki w Go (Golang): parametry typów, ograniczenia i przykłady

Funkcja generyczna

Parametry typów zapisuje się w nawiasach kwadratowych przed zwykłymi parametrami. Każdy z nich ma ograniczenie, które mówi, jakie typy są dozwolone.

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 i U są wnioskowane z argumentów, więc rzadko piszesz Map[int, string](...). Inferencja działa na podstawie argumentów funkcji; nie potrafi wywnioskować typu, który występuje tylko w wyniku. Dla func Zero[T any]() T musisz napisać Zero[int]().

Przed Go 1.18 tę funkcję trzeba było pisać osobno dla każdego typu albo przyjmować []interface{} i tracić bezpieczeństwo typów.

Ograniczenia

Ograniczenie (constraint) to interfejs. Określa, jakich typów można użyć, a w zamian mówi kompilatorowi, jakie operacje są dozwolone na wartościach tego typu.

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

Z any zamiast comparable wyrażenie v == target się nie kompiluje: invalid operation: v == target (incomparable types in type set). To ograniczenie sprawia, że operator jest dozwolony.

Te dwie funkcje pomocnicze już istnieją: slices.Index i slices.Max. Standardowe pakiety slices, maps i cmp pokrywają większość codziennych potrzeb generycznych, więc sprawdź je, zanim napiszesz własne.

Własne ograniczenia z uniami typów i ~

Ograniczenie może wymieniać typy przez |. Dozwolone są te operatory, które obsługuje każdy z wymienionych typów.

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
}

Tylda ma znaczenie. ~int64 oznacza "dowolny typ, którego typem bazowym jest int64", więc nazwany typ Cents zostaje zaakceptowany. Zapisane jako zwykłe int64, Sum([]Cents{...}) kończy się błędem Cents does not satisfy Number (possibly missing ~ for int64 in Number).

Interfejsów zawierających unie typów można używać tylko jako ograniczeń, nigdy jako zwykłych typów zmiennych. var n Number się nie kompiluje.

Pakiet golang.org/x/exp/constraints ma gotowe ograniczenia Integer, Float i Signed. Jest poza biblioteką standardową, więc tutejsze środowisko uruchomieniowe nie może go zaimportować; standardowym ograniczeniem jest cmp.Ordered.

Typy generyczne

Struktury, slice'y, mapy i inne typy też mogą mieć parametry typów. Metody typu generycznego używają parametrów odbiorcy.

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

Dwa szczegóły z tego przykładu pojawiają się bez przerwy:

• Wartość zerowa T. var zero T to sposób na zwrócenie "niczego" z kodu generycznego. Nie ma T{} ani nil, które działałyby dla każdego typu.
• Instancjonowanie. Typ generyczny trzeba zinstancjonować przed użyciem: Stack[string], a nie Stack. Wewnątrz jego własnych metod odbiorcę zapisuje się jako Stack[T].

Go 1.24 dodało generyczne aliasy typów: type Set[T comparable] = map[T]struct{} teraz się kompiluje.

Ograniczenia, na które trafisz

• Brak parametrów typów w metodach. func (s *Stack[T]) Map[U any](...) jest niedozwolone. Użyj funkcji na najwyższym poziomie.
• Brak specjalizacji. Nie da się napisać osobnej implementacji dla T = string. Obejściem jest switch typów na any(v) wewnątrz funkcji, a zwykle jest to znak, że generyki to złe narzędzie.
• Brak ograniczeń operatorów po nazwie. Nie da się powiedzieć "dowolny typ z metodą +"; wymieniasz typy w unii.
• Dostęp do pól przez ograniczenie nie działa. Nawet jeśli każdy typ w unii ma pole ID, v.ID jest niedozwolone. Zamiast tego użyj metody w ograniczeniu.

Kiedy nie używać generyków

Generyki pasują do typów kontenerowych (stosy, zbiory, cache, drzewa) i do algorytmów na slice'ach i mapach, które robią to samo dla każdego typu elementu. Nie pasują wszędzie.

• Jeden konkretny typ. Jeśli funkcja jest zawsze wywoływana tylko z []User, wersja generyczna dodaje koszt czytania i nic poza tym.
• Zachowanie zależne od typu. Do tego służą interfejsy. Funkcja przyjmująca io.Writer jest prostsza niż taka, która przyjmuje [T io.Writer], i działa tak samo.
• Zastępowanie parametrów interfejsowych. func Print[T fmt.Stringer](v T) nie jest lepsze od func Print(v fmt.Stringer).

Wskazówka samego zespołu Go: najpierw napisz kod dla konkretnego typu, a po parametry typów sięgnij, gdy zauważysz, że drugi raz piszesz ten sam kod, w którym zmieniają się tylko typy.

Typowe błędy

• Używanie any tam, gdzie potrzebne jest comparable lub cmp.Ordered. Kompilator odrzuca == lub < na parametrze typu any.
• Zapomniana ~. Typy zdefiniowane przez użytkownika, jak type ID int, nie spełniają zwykłego ograniczenia int.
• Zwracanie nil dla parametru typu. Niedozwolone, chyba że ograniczenie zawęża T do typów podobnych do wskaźników. Zwracaj wartość zerową.
• Pisanie generycznej funkcji pomocniczej, która już istnieje. Najpierw sprawdź slices, maps i cmp.