Comment les contraintes de type récursives peuvent-elles être obtenues dans les génériques Go à l'aide d'interfaces ?

Contraintes de type récursives avec des types prédéfinis

Dans les génériques Go, il est possible de spécifier une contrainte de type sur un type générique à l'aide d'une interface. Cependant, il peut être difficile d'imposer l'implémentation d'une méthode avec un argument de type générique.

Pour obtenir des contraintes de type récursif dans les génériques Go, nous pouvons définir une interface avec une méthode qui prend le type générique comme un argument :

type Lesser[T any] interface {
    Less(T) bool
}

On peut alors créer une fonction qui prend deux arguments de type Lesser[T] et renvoie un boolean :

func IsLess[T Lesser[T]](x, y T) bool {
    return x.Less(y)
}

Désormais, les types personnalisés qui implémentent l'interface Lesser[T] peuvent être utilisés dans la fonction :

type Apple int

func (a Apple) Less(other Apple) bool {
    return a < other
}

type Orange int

func (o Orange) Less(other Orange) bool {
    return o < other
}

func main() {
    fmt.Println(IsLess(Apple(10), Apple(20)))   // true
    fmt.Println(IsLess(Orange(30), Orange(15))) // false
}

La contrainte Lesser[T] garantit que les types fournis à la fonction IsLess, implémentez une méthode Less qui prend un argument du même type. Cela permet des contraintes de type récursives sans utiliser de littéraux de type.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!