interface method must have no type parameters
Ai pus parametri de tip pe o metodă dintr-o interfață (Pune[T any](v T)). Metodele din interfețe nu pot fi generice; fă interfața însăși generică, type Cache[T any] interface { Pune(cheie string, v T) }, și alege T când o folosești.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
O interfață descrie un set fix de metode, iar Go trebuie să poată verifica, pentru orice tip, dacă le are pe toate. O metodă generică într-o interfață (Pune[T any](cheie string, v T)) ar cere ca tipul să aibă o variantă pentru orice T posibil, lucru care nu se poate verifica și nici implementa eficient. De aceea compilatorul spune interface method must have no type parameters. Pe aceeași linie apare des și undefined: T, pentru că parametrul respins nu mai e cunoscut în restul semnăturii.
În versiunile recente de Go (ca Go 1.27, folosit aici), metodele tipurilor concrete pot avea parametri de tip, dar cele din interfețe tot nu. Soluția obișnuită este să muți parametrul la nivelul interfeței: type Cache[T any] interface { ... }, apoi Cache[int], Cache[string].
De ce apare: cauzele frecvente
1Metodă generică într-o interfață
type Cache interface {
Pune[T any](cheie string, v T)
Ia[T any](cheie string) (T, bool)
}type Cache[T any] interface {
Pune(cheie string, v T)
Ia(cheie string) (T, bool)
}Parametrul de tip al interfeței se alege o singură dată (Cache[int]), iar metodele îl folosesc ca pe un tip obișnuit.
2Funcție utilitară gândită ca metodă de interfață
type Convertor interface {
In[T any](s string) T
}func Converteste[T any](s string, f func(string) T) T {
return f(s)
}Când tipul diferă de la un apel la altul, o funcție generică liberă e mai simplă decât o interfață.
Repară eroarea, direct în pagină
Interfața Cache declară metode generice și programul nu compilează: interface method must have no type parameters. Fă interfața generică (parametrul T la nivelul ei), păstrând implementarea MapCache[T], ca programul să afișeze:
mouse 79 true
tastatura 0 falsepackage main
import "fmt"
type Cache interface {
Pune[T any](cheie string, v T)
Ia[T any](cheie string) (T, bool)
}
type MapCache[T any] struct{ date map[string]T }
func (m *MapCache[T]) Pune(cheie string, v T) { m.date[cheie] = v }
func (m *MapCache[T]) Ia(cheie string) (T, bool) {
v, ok := m.date[cheie]
return v, ok
}
func main() {
var c Cache = &MapCache[int]{date: map[string]int{}}
c.Pune("mouse", 79)
for _, k := range []string{"mouse", "tastatura"} {
v, ok := c.Ia(k)
fmt.Println(k, v, ok)
}
}mouse 79 true tastatura 0 false
Indiciu
Scrie type Cache[T any] interface { ... } și declară variabila ca Cache[int].
Reparația
package main
import "fmt"
type Cache[T any] interface {
Pune(cheie string, v T)
Ia(cheie string) (T, bool)
}
type MapCache[T any] struct{ date map[string]T }
func (m *MapCache[T]) Pune(cheie string, v T) { m.date[cheie] = v }
func (m *MapCache[T]) Ia(cheie string) (T, bool) {
v, ok := m.date[cheie]
return v, ok
}
func main() {
var c Cache[int] = &MapCache[int]{date: map[string]int{}}
c.Pune("mouse", 79)
for _, k := range []string{"mouse", "tastatura"} {
v, ok := c.Ia(k)
fmt.Println(k, v, ok)
}
}De ce merge
Metodele dintr-o interfață nu pot avea propriii parametri de tip, pentru că interfața trebuie să descrie un set fix de metode. Cu Cache[T any], tipul se alege o singură dată, la Cache[int], iar metodele devin Pune(string, int) și Ia(string) (int, bool). *MapCache[int] are exact aceste metode, deci implementează Cache[int]; pentru cheia lipsă, Ia întoarce valoarea zero și false.
Alte forme ale mesajului
syntax error: method must have no type parameters
Cum o eviți pe viitor
Gândește generic la nivelul tipului, nu al metodei: Stiva[T], Cache[T], Depozit[T], cu metode care folosesc T. Când ai nevoie de comportament pentru mai multe tipuri deodată, scrie funcții generice libere (func Max[T cmp.Ordered](a, b T) T). Ține interfețele mici și fără parametri de tip dacă nu e nevoie: o interfață cu any sau una specializată (CacheInt) e uneori mai clară.
Întrebări frecvente
De ce struct-urile pot avea metode generice, iar interfețele nu?
O metodă generică a unui tip concret se compilează pentru tipurile cu care o apelezi efectiv. O interfață ar trebui să garanteze metoda pentru orice tip, chiar și pentru cele pe care nu le-a văzut niciodată, iar verificarea dinamică a interfețelor nu poate face asta.
Cum folosesc o interfață generică?
O instanțiezi cu un tip: var c Cache[int] = NouMapCache[int](). Orice tip care are metodele cu T înlocuit (Pune(string, int), Ia(string) (int, bool)) o implementează.
Erori înrudite
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. 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](). invalid operation: Stiva[int] (Stiva is not a generic type) Ai pus un parametru de tip între paranteze pătrate (Stiva[int]) la un tip care nu e generic. Fie declari tipul cu parametru, type Stiva[T any] struct{...}, fie scoți [int] de la folosire. Î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.
