Generics in Golang: parametri di tipo, vincoli ed esempi

Una funzione generica

I parametri di tipo vanno tra parentesi quadre prima dei parametri normali. Ognuno ha un vincolo che dice quali tipi sono ammessi.

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 e U vengono dedotti dagli argomenti, quindi raramente scrivi Map[int, string](...). L'inferenza funziona a partire dagli argomenti della funzione; non può dedurre un tipo che compare solo nel risultato. Per func Zero[T any]() T, devi scrivere Zero[int]().

Prima di Go 1.18 questa funzione andava scritta una volta per ogni tipo, oppure doveva accettare []interface{} e rinunciare alla sicurezza dei tipi.

Vincoli

Un vincolo è un'interfaccia. Limita i tipi che si possono usare e, in cambio, dice al compilatore quali operazioni sono consentite sui valori di quel tipo.

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

Con any al posto di comparable, v == target non compila: invalid operation: v == target (incomparable types in type set). È il vincolo a rendere lecito l'operatore.

Queste due funzioni esistono già: slices.Index e slices.Max. I package standard slices, maps e cmp coprono la maggior parte delle esigenze generiche quotidiane, quindi controllali prima di scriverne di tue.

Vincoli personalizzati con unioni di tipi e ~

Un vincolo può elencare tipi con |. Gli operatori consentiti sono quelli che tutti i tipi elencati supportano.

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
}

La tilde conta. ~int64 significa "qualsiasi tipo il cui tipo sottostante è int64", quindi il tipo con nome Cents viene accettato. Scritto come semplice int64, Sum([]Cents{...}) fallisce con Cents does not satisfy Number (possibly missing ~ for int64 in Number).

Le interfacce che contengono unioni di tipi si possono usare solo come vincoli, mai come tipi di variabili normali. var n Number non compila.

Il package golang.org/x/exp/constraints ha vincoli pronti come Integer, Float e Signed. È fuori dalla libreria standard, quindi l'ambiente di esecuzione di questa pagina non può importarlo; cmp.Ordered è quello standard.

Tipi generici

Anche struct, slice, mappe e altri tipi possono avere parametri di tipo. I metodi di un tipo generico usano i parametri del receiver.

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

Due dettagli di questo esempio ricorrono di continuo:

• Il valore zero di T. var zero T è il modo per restituire "niente" dal codice generico. Non esiste un T{} o un nil che funzioni per ogni tipo.
• L'istanziazione. Un tipo generico va istanziato prima dell'uso: Stack[string], non Stack. Dentro i suoi metodi, il receiver si scrive Stack[T].

Go 1.24 ha aggiunto gli alias di tipo generici: type Set[T comparable] = map[T]struct{} ora compila.

Limiti in cui ti imbatterai

• Niente parametri di tipo sui metodi. func (s *Stack[T]) Map[U any](...) non è consentito. Usa una funzione di primo livello.
• Niente specializzazione. Non puoi scrivere un'implementazione separata per T = string. Un type switch su any(v) dentro la funzione è la soluzione alternativa, e di solito è un indizio che i generics sono lo strumento sbagliato.
• Niente vincoli sugli operatori per nome. Non puoi dire "qualsiasi tipo con un metodo +"; elenchi i tipi in un'unione.
• L'accesso ai campi tramite un vincolo non funziona. Anche se ogni tipo di un'unione ha un campo ID, v.ID non è consentito. Metti invece un metodo nel vincolo.

Quando non usare i generics

I generics sono adatti ai tipi contenitore (stack, set, cache, alberi) e agli algoritmi su slice e mappe che fanno la stessa cosa per ogni tipo di elemento. Non vanno bene ovunque.

• Un solo tipo concreto. Se la funzione viene chiamata sempre e solo con []User, una versione generica aggiunge fatica nella lettura e nient'altro.
• Comportamento che cambia in base al tipo. Per questo esistono le interfacce. Una funzione che accetta un io.Writer è più semplice di una che accetta [T io.Writer], e funziona allo stesso modo.
• Sostituire i parametri interfaccia. func Print[T fmt.Stringer](v T) non è meglio di func Print(v fmt.Stringer).

La linea guida del team di Go: scrivi prima il codice per un tipo specifico, e ricorri ai parametri di tipo quando ti accorgi di scrivere lo stesso codice una seconda volta cambiando solo i tipi.

Errori comuni

• Usare any dove serve comparable o cmp.Ordered. Il compilatore rifiuta == o < su un parametro di tipo any.
• Dimenticare ~. I tipi definiti dall'utente come type ID int non soddisfano un vincolo int semplice.
• Restituire nil per un parametro di tipo. Non è consentito, a meno che il vincolo non limiti T a tipi simili ai puntatori. Restituisci un valore zero.
• Scrivere una funzione generica di supporto che esiste già. Controlla prima slices, maps e cmp.