pointers - seguro - X no implementa Y(... el método tiene un receptor de puntero)

unsafe c#

Question

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.

Answer 1

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 llamado T , 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ónimo T , los conjuntos de métodos de S y *S incluyen métodos promovidos con el receptor T 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 de S y *S incluyen métodos promovidos con el receptor T 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))

Answer 2

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)
}

Answer 3

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