“<tipo> é uma confusão de ponteiro para interface, não interface”

Caros colegas desenvolvedores,

Estou com um problema que me parece um pouco estranho. Dê uma olhada neste snippet de código:

package coreinterfaces

type FilterInterface interface {
    Filter(s *string) bool
}

type FieldFilter struct {
    Key string
    Val string
}

func (ff *FieldFilter) Filter(s *string) bool {
    // Some code
}

type FilterMapInterface interface {
    AddFilter(f *FilterInterface) uuid.UUID     
    RemoveFilter(i uuid.UUID)                   
    GetFilterByID(i uuid.UUID) *FilterInterface
}

type FilterMap struct {
    mutex   sync.Mutex
    Filters map[uuid.UUID]FilterInterface
}

func (fp *FilterMap) AddFilter(f *FilterInterface) uuid.UUID {
    // Some code
}

func (fp *FilterMap) RemoveFilter(i uuid.UUID) {
    // Some code
}

func (fp *FilterMap) GetFilterByID(i uuid.UUID) *FilterInterface {
    // Some code
}

Em algum outro pacote, tenho o seguinte código:

func DoFilter() {
    fieldfilter := &coreinterfaces.FieldFilter{Key: "app", Val: "152511"}
    filtermap := &coreinterfaces.FilterMap{}
    _ = filtermap.AddFilter(fieldfilter) // <--- Exception is raised here
}

O tempo de execução não aceitará a linha mencionada porque

"não pode usar fieldfilter (tipo * coreinterfaces.FieldFilter) como tipo * coreinterfaces.FilterInterface no argumento para fieldint.AddFilter: * coreinterfaces.FilterInterface é um ponteiro para interface, não interface"

No entanto, ao alterar o código para:

func DoBid() error {
    bs := string(b)
    var ifilterfield coreinterfaces.FilterInterface
    fieldfilter := &coreinterfaces.FieldFilter{Key: "app", Val: "152511"}
    ifilterfield = fieldfilter
    filtermap := &coreinterfaces.FilterMap{}
    _ = filtermap.AddFilter(&ifilterfield)
}

Tudo está bem e ao depurar o aplicativo parece realmente incluir

Estou um pouco confuso sobre este assunto. Ao olhar para outras postagens de blog e tópicos de estouro de pilha discutindo exatamente o mesmo problema (por exemplo - This ou This ), o primeiro snippet que levanta essa exceção deve funcionar, porque fieldfilter e fieldmap são inicializados como ponteiros para interfaces, em vez de valor de interfaces. Não consegui entender o que realmente acontece aqui e que preciso mudar para não declarar um FieldInterface e atribuir a implementação para essa interface. Deve haver uma maneira elegante de fazer isso.

Então você está confundindo dois conceitos aqui. Um ponteiro para uma estrutura e um ponteiro para uma interface não são iguais. Uma interface pode armazenar uma estrutura diretamente ou um ponteiro para uma estrutura. No último caso, você ainda usa a interface diretamente, não um ponteiro para a interface. Por exemplo:

type Fooer interface {
    Dummy()
}

type Foo struct{}

func (f Foo) Dummy() {}

func main() {
    var f1 Foo
    var f2 *Foo = &Foo{}

    DoFoo(f1)
    DoFoo(f2)
}

func DoFoo(f Fooer) {
    fmt.Printf("[%T] %+v\n", f, f)
}

Resultado:

[main.Foo] {}
[*main.Foo] &{}

https://play.golang.org/p/I7H_pv5H3Xl

Em ambos os casos, a fvariável em DoFooé apenas uma interface, não um ponteiro para uma interface. No entanto, ao armazenar f2, a interface mantém um ponteiro para uma Fooestrutura.

Ponteiros para interfaces quase nunca são úteis. Na verdade, o tempo de execução Go foi alterado especificamente algumas versões de volta para não mais desreferenciar ponteiros de interface automaticamente (como faz para ponteiros de estrutura), para desencorajar seu uso. Na esmagadora maioria dos casos, um ponteiro para uma interface reflete um mal-entendido sobre como as interfaces deveriam funcionar.

No entanto, há uma limitação nas interfaces. Se você passar uma estrutura diretamente para uma interface, apenas os métodos de valor desse tipo (ou seja,func (f Foo) Dummy() , não func (f *Foo) Dummy()) podem ser usados ​​para preencher a interface. Isso ocorre porque você está armazenando uma cópia da estrutura original na interface, de modo que os métodos de ponteiro teriam efeitos inesperados (ou seja, incapaz de alterar a estrutura original). Portanto, a regra padrão é armazenar ponteiros para estruturas em interfaces , a menos que haja uma razão convincente para não fazê-lo.

Especificamente com seu código, se você alterar a assinatura da função AddFilter para:

func (fp *FilterMap) AddFilter(f FilterInterface) uuid.UUID

E a assinatura GetFilterByID para:

func (fp *FilterMap) GetFilterByID(i uuid.UUID) FilterInterface

Seu código funcionará conforme o esperado. fieldfilteré do tipo*FieldFilter , que preenche o FilterInterfacetipo de interface e, portanto AddFilter, o aceita.

Aqui estão algumas boas referências para entender como métodos, tipos e interfaces funcionam e se integram no Go:

• https://medium.com/@agileseeker/go-interfaces-pointers-4d1d98d5c9c6
• https://www.goinggo.net/2014/05/methods-interfaces-and-embedded-types.html
• https://blog.golang.org/laws-of-reflection

GetFilterByID(i uuid.UUID) *FilterInterface

Quando recebo esse erro, geralmente é porque estou especificando um ponteiro para uma interface em vez de uma interface (que na verdade será um ponteiro para minha estrutura que preenche a interface).

Há um uso válido para * interface {...} mas, mais comumente, estou pensando 'isto é um ponteiro' em vez de 'esta é uma interface que por acaso é um ponteiro no código que estou escrevendo'

Só estou lançando porque a resposta aceita, embora detalhada, não me ajudou a resolver o problema.