Comment remplir une tranche d'interfaces avec des types concrets dans Golang Generics ?

Génériques Golang : utilisation simultanée de l'interface et du type concret

Dans Go 1.18, les génériques ont introduit de nouvelles possibilités de gestion des types. Cependant, certains scénarios peuvent poser des défis lors de l'utilisation conjointe d'interfaces et de types concrets.

Un de ces scénarios se produit lorsque l'on tente de créer une fonction comme celle-ci :

<code class="go">func Fill[X any](slice []*X){
   for i := range slice {
      slice[i] = new(X)
   }
}</code>

Cette fonction est destinée à remplir un tranche d'interfaces avec des types concrets. Par exemple, un tableau de *int peut être rempli avec new(int) à l'aide de cette fonction.

Le problème survient lorsque l'on essaie de remplir une tranche d'interfaces avec un type concret qui implémente l'interface. Considérez ce code :

<code class="go">func Fill[X, Y any](slice []X){
   for i := range slice {
      slice[i] = new(Y) // not work!
   }
}

xs := make([]sync.Locker, 10) // fill with nils
Fill[sync.Locker,sync.Mutex](xs) // ouch</code>

Dans ce cas, la fonction ne fonctionne pas car contraindre X et Y à any rompt la relation entre l'interface et le type d'implémentation. Le compilateur ne reconnaît que X et Y sont des types distincts au moment de la compilation.

Une solution possible

Il existe une solution de contournement pour compiler le code à l'aide d'une assertion explicite :

<code class="go">func Fill[X, Y any](slice []X) {
    for i := range slice {
        slice[i] = any(*new(Y)).(X)
    }
}</code>

Cependant, cette solution présente un inconvénient important : elle panique si Y n'implémente pas X, comme avec sync.Locker et sync.Mutex. De plus, l'utilisation d'un type de pointeur pour Y entraîne des valeurs nulles car il perd le type de base et les informations sur la valeur nulle.

Une meilleure alternative

Une solution plus robuste consiste à utiliser une fonction constructeur au lieu de le deuxième paramètre de type :

<code class="go">func main() {
    xs := make([]sync.Locker, 10)
    Fill(xs, func() sync.Locker { return &sync.Mutex{} })
}

func Fill[X any](slice []X, f func() X) {
    for i := range slice {
        slice[i] = f()
    }
}</code>

Dans cette approche, la fonction prend une tranche de type X et une fonction constructeur. La fonction constructeur crée une instance de type X, remplissant la tranche d'instances concrètes.

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!