not enough type arguments for type Pereche: have 1, want 2
Un tip generic cu mai mulți parametri (Pereche[K, V]) a fost folosit cu prea puține argumente de tip (Pereche[string]). Spre deosebire de funcții, la tipuri Go nu deduce argumentele: scrie-le pe toate, de exemplu Pereche[string, int].
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Când declari un tip generic, type Pereche[K comparable, V any] struct{...}, fiecare folosire a lui trebuie să precizeze toți parametrii de tip: Pereche[string, int]. Dacă dai mai puțini, compilatorul spune câți ai și câți trebuie: not enough type arguments for type Pereche: have 1, want 2. Dacă dai mai mulți: too many type arguments for type Pereche: have 3, want 2. Fără niciun argument: cannot use generic type Pereche[K comparable, V any] without instantiation.
La funcțiile generice Go deduce adesea tipurile din argumente (Max(3, 5)), dar la tipuri (în declarații de variabile, câmpuri, parametri) nu există deducție. Pentru un literal (Pereche[string, int]{...}) trebuie de asemenea scrise.
În metodele tipului generic, receiver-ul repetă parametrii: func (p Pereche[K, V]) Cheie() K.
De ce apare: cauzele frecvente
1Un argument uitat
type Pereche[K comparable, V any] struct {
Cheie K
Val V
}
var p Pereche[string]type Pereche[K comparable, V any] struct {
Cheie K
Val V
}
var p Pereche[string, int]Ambii parametri, K și V, trebuie să primească un tip concret.
2Receiver-ul metodei fără parametri
func (p Pereche) Afiseaza() {
fmt.Println(p.Cheie, p.Val)
}func (p Pereche[K, V]) Afiseaza() {
fmt.Println(p.Cheie, p.Val)
}Aici mesajul este cannot use generic type Pereche[K comparable, V any] without instantiation; receiver-ul repetă numele parametrilor.
3Funcție generică apelată cu prea multe tipuri
func Max[T cmp.Ordered](a, b T) T { ... }
m := Max[int, int](1, 2)func Max[T cmp.Ordered](a, b T) T { ... }
m := Max(1, 2)Max are un singur parametru de tip, iar Go îl poate deduce. Mesajul aici este got 2 type arguments but want 1.
Repară eroarea, direct în pagină
Tipul generic Pereche păstrează un nume de produs și cantitatea lui, dar variabila e declarată cu un singur argument de tip și compilarea se oprește cu not enough type arguments for type Pereche: have 1, want 2. Completează argumentele ca programul să afișeze mouse: 12.
package main
import "fmt"
type Pereche[K comparable, V any] struct {
Cheie K
Val V
}
func main() {
var p Pereche[string]
p.Cheie = "mouse"
p.Val = 12
fmt.Printf("%v: %v\n", p.Cheie, p.Val)
}mouse: 12
Indiciu
Cheia este string, iar valoarea este int.
Reparația
package main
import "fmt"
type Pereche[K comparable, V any] struct {
Cheie K
Val V
}
func main() {
var p Pereche[string, int]
p.Cheie = "mouse"
p.Val = 12
fmt.Printf("%v: %v\n", p.Cheie, p.Val)
}De ce merge
Pereche are doi parametri de tip, K și V, iar la tipuri Go nu deduce argumentele, deci trebuie scrise amândouă. Pereche[string, int] înseamnă un struct cu Cheie string și Val int. După asta, atribuirile se potrivesc exact cu tipurile câmpurilor.
Alte forme ale mesajului
too many type arguments for type P: have 3, want 2got 2 type arguments but want 1
Cum o eviți pe viitor
Când un tip generic apare des cu aceleași argumente, dă-i un alias sau un tip propriu: type Stoc = Pereche[string, int]. Ține numărul de parametri de tip mic (unul sau doi). În metode, copiază exact lista din declarația tipului, fără constrângeri: [K, V].
Întrebări frecvente
De ce Go deduce tipurile la funcții, dar nu la tipuri?
La un apel de funcție tipurile argumentelor sunt cunoscute, deci T se poate deduce. O declarație var p Pereche nu are de unde să afle ce tipuri vrei.
Pot avea valori implicite pentru parametrii de tip?
Nu. Fiecare parametru de tip trebuie dat explicit la folosirea tipului.
Erori înrudite
in call to NouaCoada, cannot infer T Funcția generică nu primește niciun argument din care Go să deducă parametrul de tip T (de obicei o funcție care creează ceva gol). Dă tipul explicit la apel: NouaCoada[string](). cannot use type Numar outside a type constraint: interface contains type constraints O interfață cu o listă de tipuri (interface{ int | float64 }) sau cmp.Ordered este o constrângere pentru generice, nu un tip obișnuit: nu poți declara variabile, parametri sau slice-uri de acel tip. Folosește-o între paranteze drepte: func Suma[T Numar](x []T) T. string does not satisfy Numar (string missing in int | float64) Apelezi o funcție generică cu un tip care nu respectă constrângerea parametrului de tip. Aici Numar acceptă doar int și float64, iar tu ai trimis string. Trimite un tip permis sau extinde constrângerea (de exemplu cu cmp.Ordered dacă ai nevoie doar de comparații). Învață Go de la zero, cu exerciții la fiecare lecție
Curs Go: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
