Comment parcourir une union de tranches dans les fonctions génériques Go ?

Itération sur une union de tranches dans des fonctions génériques

Les génériques dans Go permettent aux fonctions d'opérer sur une gamme de types, permettant la réutilisation du code et tapez la sécurité. Cependant, lorsque vous travaillez avec des tranches de différents types d'éléments, il peut y avoir des difficultés lors de leur itération dans des fonctions génériques.

Considérez l'exemple suivant qui vise à résumer les éléments d'une tranche, contenant potentiellement des entiers ou des flottants :

package main

import "fmt"

// NumberSlice constraint
type NumberSlice interface {
    []int64 | []float64
}

func add[N NumberSlice](n N) {
    // want: to range over n and print value of v
    for _, v := range n {
        fmt.Println(v)
    }
}

func main() {
    ints := []int64{1, 2}
    add(ints)
}

Lors de l'exécution de ce code, l'erreur suivante se produit :

cannot range over n (variable of type N constrained by NumberSlice) (N has no core type)

Le problème réside dans l'absence d'un "noyau type" pour la contrainte d'interface NumberSlice. Un type principal représente un type sous-jacent unique partagé par tous les types du jeu de types de l'interface. Étant donné que NumberSlice englobe à la fois []int64 et []float64, il n'a pas de type de base.

Pour résoudre ce problème, il existe plusieurs approches :

1. Appliquer un type de base commun :
   Modifier la contrainte d'interface pour spécifier les types de base et stipuler le type de tranche au sein de la fonction signature :

   type Number interface {
       int64 | float64
   }
   
   func add[N Number](n []N) {
       for _, v := range n {
           fmt.Println(v)
       }
   }

2. Utiliser des génériques avec un typage explicite :
   Déclarez un type de tranche générique qui spécifie le type d'élément et utilisez un typage explicite pour indiquer le type souhaité type d'élément :

   type NumberSlice[N int64 | float64] interface {
       ~[]N // indicates a core type of []N
   }
   
   func add[S NumberSlice[N], N int64 | float64](n S) {
       for _, v := range n {
           fmt.Println(v)
       }
   }

En spécifiant un type de noyau, le compilateur peut déduire le comportement d'itération approprié, permettant l'opération souhaitée d'itération sur la tranche au sein de la fonction générique.

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!