Les génériques (ajoutées en Go 1.18) vous permettent d'écrire des fonctions et des types qui fonctionnent avec plusieurs types via des paramètres de type, tout en maintenant la sécurité des types à la compilation. Ils éliminent l'ancien compromis consistant à dupliquer le code par type ou à perdre la sécurité avec interface{}.
{ ... }
{ ... }
{} { ... }
// T is a type parameter constrained to be "ordered" (comparable with < >)
func Max[T constraints.Ordered](a, b T) T {
if a > b {
return a
}
return b
}
Max(3, 5) // T inferred as int → 5
Max(2.5, 1.1) // T inferred as float64 → 2.5
Max("a", "b") // T inferred as string → "b"
Le [T constraints.Ordered] déclare un paramètre de type T avec une contrainte (les types autorisés). Le compilateur déduit T à partir des arguments — une implémentation fonctionne pour de nombreux types, entièrement type-safe.
// a constraint is an interface listing allowed types or required methods
type Number interface {
~int | ~int64 | ~float64 // the | union means "any of these"
}
func Sum[T Number](nums []T) T {
var total T
for _, n := range nums {
total += n // safe — T is constrained to numeric types
}
return total
}
Sum([]int{1, 2, 3}) // 6
Sum([]float64{1.5, 2.5}) // 4.0
// built-in constraints:
any // any type (alias for interface{})
comparable // types usable with == (for map keys, etc.)
// golang.org/x/exp/constraints: Ordered, Integer, Float, etc.
Les contraintes définissent quelles opérations sont valides sur le paramètre de type (le ~ signifie « tout type dont le type sous-jacent est celui-ci »).
// a generic stack that works for any type
type Stack[T any] struct {
items []T
}
func (s *Stack[T]) Push(item T) { s.items = append(s.items, item) }
func (s *Stack[T]) Pop() T {
item := s.items[len(s.items)-1]
s.items = s.items[:len(s.items)-1]
return item
}
intStack := Stack[int]{} // a stack of ints
strStack := Stack[string]{} // a stack of strings — same code
✓ Generic data structures (stacks, trees, sets), utility functions over collections
(Map, Filter, Reduce), type-safe containers
✗ Don't overuse — if interfaces or a concrete type work simply, prefer them.
Go's philosophy still favors simplicity; generics are a tool, not a default.
Les génériques ont été un ajout majeur et longtemps attendu à Go (1.18) qui a résolu un vrai point de friction : avant, écrire du code réutilisable pour plusieurs types vous forçait soit à le dupliquer par type (verbeux, difficile à maintenir) soit à utiliser interface{} (perdant la sécurité des types à la compilation et nécessitant des assertions en temps d'exécution).
Les génériques vous permettent d'écrire des fonctions et structures de données type-safe et réutilisables (conteneurs, utilitaires de collection comme Map/Filter/Reduce) une seule fois, le compilateur appliquant la correction et déduisant les types.
Comprendre les paramètres de type, les contraintes (y compris any, comparable, et la syntaxe union/~), et les types génériques est de plus en plus important à mesure que l'écosystème les adopte.
Également important est la philosophie Go selon laquelle les génériques sont un outil pour une véritable réutilisation, pas un défaut — les surcharger va à l'encontre de la philosophie de simplicité de Go.
C'est un sujet actuel, fréquemment discuté, reflétant une maîtrise du Go moderne.