Erreur Go : impossible d'utiliser le type générique sans instanciation

Ce que l'éditeur PHP Apple souhaite partager avec vous aujourd'hui concerne un bug du langage Go : les types génériques ne peuvent pas être utilisés sans instanciation. Dans le langage Go, les génériques sont une fonctionnalité très puissante qui nous permet d'écrire du code plus polyvalent et flexible. Cependant, nous pouvons parfois rencontrer un problème où nous ne pouvons pas utiliser un type générique sans instanciation. Cette erreur peut nous laisser perplexes quant à la façon de la corriger. Examinons ensuite les causes et les solutions à ce problème !

Contenu de la question

En apprenant les génériques de Go, j'ai rencontré une erreur que je n'arrivais pas à résoudre. Je l'ai résumé au code le plus simple :

type opStack[T any] []T

func main() {

    t := make(opStack)
    //  t := new(opStack)
    t = append(t, 0)
    fmt.Println(t[0])
}

Dans Playground, similaire à l'appel make() 调用（以及在已注释掉的 new), le message d'erreur suivant apparaît :

cannot use generic type opStack[T any] without instantiation

Mais make() est une fonction d'instanciation. Donc, j'espère qu'il me manque une subtilité de syntaxe. De quoi Go se plaint-il et qu’est-ce qui doit être corrigé ? make() 是一个实例化函数。所以，我希望我错过了一些语法上的微妙之处。 Go 抱怨什么以及需要纠正什么？

解决方法

每当您使用参数化类型时，包括需要类型参数的任何地方，例如内置的 makeSolution de contournement

Chaque fois que vous utilisez un type paramétré,y compris partout où un paramètre de type est requis, tel que lemake intégré, vous devez remplacer le paramètre de type dans sa définition par le type réel. C'est ce qu'on appelle l'instanciation.

t := make(opStack[int], 0)
t = append(t, 0)

Si vous utilisez un type générique comme

paramètre de type d'un autre

type générique, vous devez également l'instancier :

type Data[T any] struct {
    data T
}

d := Data[opStack[int]]{ data: []int{0, 1, 2} }

Vous pouvez utiliser des paramètres de type pour l'instanciation, par exemple dans les signatures de fonctions, les champs et les définitions de type : 一个>

type FooBar[T any] struct {
    ops opStack[T]
}

type OpsMap[T any] map[string]opStack[T]

func echo[T any](ops opStack[T]) opStack[T] { return ops }

Les références pertinentes dans la spécification du langage se trouvent (actuellement) à deux endroits différents,

définitions de type :

et

instanciation

Dans d'autres langages de programmation, « instanciation » peut faire référence à la création d'une instance d'un objet – dans Go, le terme fait spécifiquement référence au remplacement des paramètres de type par des types concrets. À mon avis, l'usage du terme est toujours cohérent, même si en Go cela ne signifie pas nécessairement allocation.

Notez que vous pouvez appeler des fonctions génériques sans paramètres de type explicites. L'instanciation se produit là aussi, c'est juste que les paramètres de type peuvent tous être déduits des paramètres de fonction :

func Print[T, U any](v T, w U) { /* ... */ }

Print("foo", 4.5) // T is inferred from "foo", U from 4.5

Le raisonnement fonctionnait également pour les 🎜types🎜 génériques, avec la restriction que la liste des paramètres de type doit être non vide. Mais cette fonctionnalité est désactivée, vous devez donc fournir explicitement tous les paramètres de type. 🎜

type Vector[T any] []T 
// v := Vector[int]{} -> must supply T

type Matrix[T any, U ~[]T] []U 
// m := Matrix[int, []int]{} -> must supply T and U

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!