Les génériques

Le problème : écrire deux fois le même code

Vous voulez une fonction qui renvoie le plus grand de deux valeurs. Pour des int, facile. Mais pour des float64, il faut la réécrire à l'identique, juste avec un autre type :

func MaxInt(a, b int) int {
    if a > b { return a }
    return b
}

func MaxFloat(a, b float64) float64 {  // exactement le même code...
    if a > b { return a }
    return b
}

Avant Go 1.18, on n'avait que deux mauvaises options : dupliquer (une fonction par type), ou passer par interface{} et perdre toute la sécurité de typage (et payer des conversions). Les génériques règlent ça.

Les paramètres de type [T]

Un paramètre de type se déclare entre crochets, juste après le nom de la fonction. T est un type « à trous » que le compilateur remplit à l'appel :

func Max[T int | float64](a, b T) T {
    if a > b {
        return a
    }
    return b
}

func main() {
    fmt.Println(Max(3, 5))        // 5   → T vaut int
    fmt.Println(Max(2.5, 1.0))    // 2.5 → T vaut float64
}

[T int | float64] dit : « T peut être un int ou un float64 ». Une seule fonction, et le compilateur génère la bonne version pour chaque type d'appel, sans perdre le typage.

Les contraintes : ce que T a le droit d'être

Le bout entre crochets s'appelle une contrainte : elle limite les types autorisés ET détermine les opérations permises sur T. Trois cas à connaître :

• any : n'importe quel type (c'est l'alias de interface{}). Mais alors on ne peut presque rien faire sur T à part le stocker.
• comparable : les types qu'on peut comparer avec == et != (utile pour les clés de map).
• une contrainte sur mesure : une interface qui énumère des types.

// ~int signifie "int et tout type dont le sous-jacent est int"
type Nombre interface {
    ~int | ~int64 | ~float64
}

func Somme[T Nombre](valeurs []T) T {
    var total T
    for _, v := range valeurs {
        total += v          // autorisé : la contrainte garantit le +
    }
    return total
}

Pour les types ordonnés, la bibliothèque standard fournit déjà cmp.Ordered (Go 1.21) : func Max[T cmp.Ordered](a, b T) T couvre d'un coup les nombres ET les string.

Les types génériques

Pas que les fonctions : un type aussi peut être paramétré. L'exemple classique, une pile (stack) qui marche pour n'importe quel type :

type Pile[T any] struct {
    elements []T
}

func (p *Pile[T]) Empiler(v T) {
    p.elements = append(p.elements, v)
}

func (p *Pile[T]) Depiler() (T, bool) {
    var zero T
    if len(p.elements) == 0 {
        return zero, false
    }
    dernier := p.elements[len(p.elements)-1]
    p.elements = p.elements[:len(p.elements)-1]
    return dernier, true
}

func main() {
    var p Pile[string]   // une pile de strings, typée
    p.Empiler("a")
    p.Empiler("b")
    v, ok := p.Depiler()
    fmt.Println(v, ok)   // b true
}

La même Pile sert pour Pile[int], Pile[Compte], etc. : un seul code, typé et vérifié à la compilation pour chaque usage.

Quand (et quand ne pas) les utiliser

Les génériques brillent pour les conteneurs (piles, listes, caches) et les algorithmes qui traitent plein de types de la même façon (Map, Filter, Somme). Mais ils ne remplacent pas les interfaces.

À toi : complète cette fonction générique Contient qui dit si une valeur est dans un slice, puis exécute :

package main

import "fmt"

// Contient renvoie true si v est présent dans s.
func Contient[T comparable](s []T, v T) bool {
    for _, e := range s {
        if e == v {     // == est permis grâce à comparable
            return true
        }
    }
    return false
}

func main() {
    fmt.Println(Contient([]int{1, 2, 3}, 2))         // true
    fmt.Println(Contient([]string{"a", "b"}, "z"))   // false
}