pointers - seguro - X no implementa Y(... el método tiene un receptor de puntero)
unsafe c# (3)
Ya hay varias preguntas y respuestas sobre esta cosa " X no implementa Y (... el método tiene un receptor de puntero) ", pero para mí, parecen estar hablando de cosas diferentes y no se aplican a mi caso específico.
Entonces, en lugar de hacer la pregunta muy específica, la hago amplia y abstracta: parece que hay varios casos diferentes que pueden hacer que este error ocurra, ¿alguien puede resumirlo por favor?
Es decir, cómo evitar el problema, y si ocurre, ¿cuáles son las posibilidades? Gracias.
Este error en tiempo de compilación surge cuando intenta asignar o pasar (o convertir) un tipo concreto a un tipo de interfaz; y el tipo en sí no implementa la interfaz, solo un puntero al tipo .
Veamos un ejemplo:
type Stringer interface {
String() string
}
type MyType struct {
value string
}
func (m *MyType) String() string { return m.value }
El tipo de interfaz
Stringer
tiene un solo método:
String()
.
Cualquier valor almacenado en un valor de interfaz
Stringer
debe tener este método.
También creamos un
MyType
, y creamos un método
MyType.String()
con
puntero
receptor.
Esto significa que el método
String()
está en el
conjunto
de
*MyType
tipo
*MyType
, pero no en el de
MyType
.
Cuando intentamos asignar un valor de
MyType
a una variable de tipo
Stringer
, obtenemos el error en cuestión:
m := MyType{value: "something"}
var s Stringer
s = m // cannot use m (type MyType) as type Stringer in assignment:
// MyType does not implement Stringer (String method has pointer receiver)
Pero todo está bien si intentamos asignar un valor de tipo
*MyType
a
Stringer
:
s = &m
fmt.Println(s)
Y obtenemos el resultado esperado (pruébalo en Go Playground ):
something
Entonces, los requisitos para obtener este error en tiempo de compilación:
- Un valor de tipo concreto sin puntero que se asigna (o se pasa o se convierte)
- Un tipo de interfaz que se asigna (o se pasa o se convierte)
- El tipo concreto tiene el método requerido de la interfaz, pero con un receptor de puntero
Posibilidades para resolver el problema:
- Se debe utilizar un puntero al valor, cuyo conjunto de métodos incluirá el método con el receptor del puntero
- O bien, el tipo de receptor debe cambiarse a sin puntero , por lo que el conjunto de métodos del tipo concreto sin puntero también contendrá el método (y, por lo tanto, satisfará la interfaz). Esto puede o no ser viable, ya que si el método tiene que modificar el valor, un receptor sin puntero no es una opción.
Estructuras e incrustaciones
Cuando se utilizan
estructuras e incrustaciones
, a menudo no es "usted" quien implementa una interfaz (proporcione una implementación de método), sino un tipo que incrusta en su
struct
.
Como en este ejemplo:
type MyType2 struct {
MyType
}
m := MyType{value: "something"}
m2 := MyType2{MyType: m}
var s Stringer
s = m2 // Compile-time error again
De nuevo, error en tiempo de compilación, porque el conjunto de métodos de
MyType2
no contiene el método
String()
del incrustado
MyType
, solo el conjunto de métodos de
*MyType2
, por lo que funciona lo siguiente (pruébelo en
Go Playground
):
var s Stringer
s = &m2
También podemos hacer que funcione, si incorporamos
*MyType
y usamos solo un
MyType2
sin puntero
(pruébelo en
Go Playground
):
type MyType2 struct {
*MyType
}
m := MyType{value: "something"}
m2 := MyType2{MyType: &m}
var s Stringer
s = m2
Además, lo que sea que incrustamos (ya sea
MyType
o
*MyType
), si usamos un puntero
*MyType2
, siempre funcionará (pruébelo en
Go Playground
):
type MyType2 struct {
*MyType
}
m := MyType{value: "something"}
m2 := MyType2{MyType: &m}
var s Stringer
s = &m2
Sección relevante de la especificación (de la sección Tipos de estructura ):
Dado un tipo de estructura
S
y un tipo llamadoT
, los métodos promocionados se incluyen en el conjunto de métodos de la estructura de la siguiente manera:
- Si
S
contiene un campo anónimoT
, los conjuntos de métodos deS
y*S
incluyen métodos promovidos con el receptorT
El conjunto de métodos de*S
también incluye métodos promovidos con el receptor*T
- Si
S
contiene un campo anónimo*T
, los conjuntos de métodos deS
y*S
incluyen métodos promovidos con el receptorT
o*T
En otras palabras: si incorporamos un tipo sin puntero, el conjunto de métodos del integrador sin puntero solo obtiene los métodos con receptores sin puntero (del tipo incrustado).
Si incrustamos un tipo de puntero, el conjunto de métodos del incrustador sin puntero obtiene métodos con receptores punteros y sin puntero (del tipo incrustado).
Si usamos un valor de puntero para el integrador, independientemente de si el tipo incrustado es puntero o no, el conjunto de métodos del puntero para el integrador siempre obtiene métodos con receptores punteros y no punteros (del tipo incrustado).
Nota:
Hay un caso muy similar, es decir, cuando tiene un valor de interfaz que envuelve un valor de
MyType
e intenta
escribir afirmar
otro valor de interfaz,
Stringer
.
En este caso, la afirmación no se mantendrá por los motivos descritos anteriormente, pero obtenemos un error de tiempo de ejecución ligeramente diferente:
m := MyType{value: "something"}
var i interface{} = m
fmt.Println(i.(Stringer))
Pánico en tiempo de ejecución (pruébalo en Go Playground ):
panic: interface conversion: main.MyType is not main.Stringer:
missing method String
Intentando convertir en lugar de escribir aserción, obtenemos el error en tiempo de compilación del que estamos hablando:
m := MyType{value: "something"}
fmt.Println(Stringer(m))
Otro caso cuando he visto este tipo de cosas es si quiero crear una interfaz donde algunos métodos modificarán un valor interno y otros no.
type GetterSetter interface {
GetVal() int
SetVal(x int) int
}
Algo que luego implementa esta interfaz podría ser:
type MyTypeA struct {
a int
}
func (m MyTypeA) GetVal() int {
return a
}
func (m *MyTypeA) SetVal(newVal int) int {
int oldVal = m.a
m.a = newVal
return oldVal
}
Por lo tanto, el tipo de implementación probablemente tendrá algunos métodos que son receptores de puntero y otros que no lo son, y dado que tengo una gran variedad de estas varias cosas que son GetterSetters, me gustaría comprobar en mis pruebas que todos están haciendo lo esperado.
Si tuviera que hacer algo como esto:
myTypeInstance := MyType{ 7 }
... maybe some code doing other stuff ...
var f interface{} = myTypeInstance
_, ok := f.(GetterSetter)
if !ok {
t.Fail()
}
Entonces no obtendré el error antes mencionado "X no implementa Y (el método Z tiene receptor de puntero)" (ya que es un error en tiempo de compilación) pero tendré un mal día persiguiendo exactamente por qué falla mi prueba ... .
En cambio, tengo que asegurarme de hacer la verificación de tipo usando un puntero, como:
var f interface{} = new(&MyTypeA)
...
O:
myTypeInstance := MyType{ 7 }
var f interface{} = &myTypeInstance
...
¡Entonces todo está contento con las pruebas!
¡Pero espera! En mi código, tal vez tengo métodos que aceptan un GetterSetter en alguna parte:
func SomeStuff(g GetterSetter, x int) int {
if x > 10 {
return g.GetVal() + 1
}
return g.GetVal()
}
Si llamo a estos métodos desde otro método de tipo, esto generará el error:
func (m MyTypeA) OtherThing(x int) {
SomeStuff(m, x)
}
Cualquiera de las siguientes llamadas funcionará:
func (m *MyTypeA) OtherThing(x int) {
SomeStuff(m, x)
}
func (m MyTypeA) OtherThing(x int) {
SomeStuff(&m, x)
}
Para mantenerlo breve, supongamos que tiene este código y tiene una interfaz Loader y un WebLoader que implementa esta interfaz.
package main
import "fmt"
// Loader defines a content loader
type Loader interface {
Load(src string) string
}
// WebLoader is a web content loader
type WebLoader struct{}
// Load loads the content of a page
func (w *WebLoader) Load(src string) string {
return fmt.Sprintf("I loaded this page %s", src)
}
func main() {
webLoader := WebLoader{}
loadContent(webLoader)
}
func loadContent(loader Loader) {
loader.Load("google.com")
}
Entonces este código le dará este error de tiempo de compilación
./main.go:20:13: no se puede usar webLoader (tipo WebLoader) como tipo Loader en argumento para cargar Contenido: WebLoader no implementa Loader (el método de carga tiene receptor de puntero)
Entonces, lo que solo necesita hacer es cambiar
webLoader := WebLoader{}
a lo siguiente:
webLoader := &WebLoader{}
Entonces, ¿por qué se solucionará porque define esta función
func (w *WebLoader) Load
para aceptar un receptor de puntero?
Para obtener más explicaciones, lea las respuestas de @icza y @karora